Tự động phát hiện góc quay trên hình ảnh tùy ý với các tính năng trực giao

Tôi có một nhiệm vụ trong tay khi tôi cần phát hiện góc của một hình ảnh như mẫu sau (một phần của ảnh vi mạch). Hình ảnh không chứa các đặc điểm trực giao, nhưng chúng có thể có kích thước khác nhau, với độ phân giải / độ sắc nét khác nhau. Hình ảnh sẽ hơi không hoàn hảo do một số biến dạng quang học và quang sai. Độ chính xác phát hiện góc pixel phụ là bắt buộc (nghĩa là nó phải ở dưới sai số <0,1 °, một cái gì đó như 0,01 ° sẽ được chấp nhận). Để tham khảo, đối với hình ảnh này góc tối ưu là khoảng 32,19 °.

Hiện tại tôi đã thử 2 cách tiếp cận: Cả hai thực hiện tìm kiếm vũ phu cho mức tối thiểu cục bộ với bước 2 °, sau đó độ dốc giảm xuống kích thước bước 0,0001 °.

Chức năng được sum(pow(img(x+1)-img(x-1), 2) + pow(img(y+1)-img(y-1))tính trên hình ảnh. Khi các đường ngang / dọc được căn chỉnh - sẽ có ít thay đổi theo hướng ngang / dọc. Độ chính xác là khoảng 0,2 °.
Chức năng là (tối đa) trên một số chiều rộng / chiều cao của hình ảnh. Dải này cũng được lặp trên hình ảnh và chức năng công đức được tích lũy. Cách tiếp cận này cũng tập trung vào sự thay đổi độ sáng nhỏ hơn khi các đường ngang / dọc được căn chỉnh, nhưng nó có thể phát hiện những thay đổi nhỏ hơn trên cơ sở lớn hơn (chiều rộng sọc - có thể rộng khoảng 100 pixel). Điều này cho độ chính xác tốt hơn, lên tới 0,01 ° - nhưng có rất nhiều thông số cần điều chỉnh (ví dụ chiều rộng / chiều cao sọc khá nhạy) có thể không đáng tin cậy trong thế giới thực.

Bộ lọc phát hiện cạnh không giúp được gì nhiều.

Mối quan tâm của tôi là thay đổi rất nhỏ trong chức năng công đức trong cả hai trường hợp giữa góc xấu nhất và tốt nhất (chênh lệch <2 lần).

Bạn có bất cứ đề nghị tốt hơn về viết chức năng công đức để phát hiện góc?

Cập nhật: Hình ảnh mẫu kích thước đầy đủ được tải lên tại đây (51 MiB)

Sau khi xử lý xong, nó sẽ trông như thế này.

image image-processing computer-vision

— BarsMonster
nguồn

Thật đáng buồn khi nó đã được chuyển từ stackoverflow sang dsp. Tôi không thấy một giải pháp giống như DSP ở đây và cơ hội bây giờ đã giảm đi nhiều. 99,9% thuật toán và thủ thuật DSP là vô ích cho nhiệm vụ này. Có vẻ như thuật toán tùy chỉnh hoặc cách tiếp cận là cần thiết ở đây, không phải là FFT.

— BarsMonster

Tôi rất vui khi nói với bạn rằng buồn là hoàn toàn sai; DSP.SE là nơi tuyệt đối đúng để hỏi điều này! (không quá nhiều stackoverflow. Đây không phải là một câu hỏi lập trình. Bạn biết lập trình của mình. Bạn không biết cách xử lý hình ảnh này.) Hình ảnh là tín hiệu và DSP.SE rất quan tâm đến việc xử lý hình ảnh! Ngoài ra, rất nhiều thủ thuật DSP chung (thậm chí được biết đến như các tín hiệu liên lạc) rất có thể áp dụng cho vấn đề của bạn :)

— Marcus Müller

Hiệu quả quan trọng như thế nào?

— Cedron Dawg

Nhân tiện, ngay cả khi chạy với độ phân giải 0,04 °, tôi khá chắc chắn góc xoay chính xác là 32 ° chứ không phải 32,19 ° - độ phân giải của ảnh gốc của bạn là gì? Bởi vì ở chiều rộng 800 px, một vòng quay không đáng lo ngại là 0,01 ° nhưng chênh lệch chiều cao 0,14 px, và điều đó thậm chí sẽ không được chú ý.

— Marcus Müller

@CedronDawg Chắc chắn không có yêu cầu thời gian thực, tôi có thể chịu đựng được khoảng 10-60 giây tính toán trên một số lõi 8-12.

— BarsMonster

Câu trả lời:

Nếu tôi hiểu chính xác phương pháp 1 của bạn, với nó, nếu bạn đã sử dụng một vùng đối xứng tròn và thực hiện xoay quanh tâm của khu vực, bạn sẽ loại bỏ sự phụ thuộc của khu vực vào góc xoay và có được sự so sánh công bằng hơn giữa chức năng công đức giữa góc quay khác nhau. Tôi sẽ đề xuất một phương pháp về cơ bản tương đương với phương pháp đó, nhưng sử dụng hình ảnh đầy đủ và không yêu cầu xoay hình ảnh lặp lại, và sẽ bao gồm bộ lọc thông thấp để loại bỏ bất đẳng hướng lưới pixel và để khử nhiễu.

Gradient của hình ảnh được lọc đẳng hướng thấp

Trước tiên, hãy tính toán một vectơ độ dốc cục bộ tại mỗi pixel cho kênh màu xanh lục trong hình ảnh mẫu kích thước đầy đủ.

Tôi đã tạo ra các hạt nhân phân biệt ngang và dọc bằng cách phân biệt đáp ứng xung không gian liên tục của bộ lọc thông thấp lý tưởng với đáp ứng tần số tròn phẳng loại bỏ hiệu ứng của sự lựa chọn trục hình ảnh bằng cách đảm bảo rằng không có mức độ chi tiết khác nhau được so sánh theo đường chéo theo chiều ngang hoặc chiều dọc, bằng cách lấy mẫu hàm kết quả và bằng cách áp dụng cửa sổ cosine xoay:

\begin{matrix} (1) & \begin{matrix} h_{x} [x, y] = {\begin{cases} 0 & if x = y = 0, \\ - \frac{ω_{c}^{2} x J_{2} (ω_{c} \sqrt{x^{2} + y^{2}})}{2 π (x^{2} + y^{2})} & otherwise, \end{cases} \\ h_{y} [x, y] = {\begin{cases} 0 & if x = y = 0, \\ - \frac{ω_{c}^{2} y J_{2} (ω_{c} \sqrt{x^{2} + y^{2}})}{2 π (x^{2} + y^{2})} & otherwise, \end{cases} \end{matrix} \end{matrix}

$\begin{gather}h_x[x, y] = \begin{cases}0&\text{if }x = y = 0,\\-\displaystyle\frac{\omega_c^2\,x\,J_2\left(\omega_c\sqrt{x^2 + y^2}\right)}{2 \pi\,(x^2 + y^2)}&\text{otherwise,}\end{cases}\\ h_y[x, y] = \begin{cases}0&\text{if }x = y = 0,\\-\displaystyle\frac{\omega_c^2\,y\,J_2\left(\omega_c\sqrt{x^2 + y^2}\right)}{2 \pi\,(x^2 + y^2)}&\text{otherwise,}\end{cases}\end{gather}\tag{1}$

Ở đâu $J_2$ là một hàm Bessel thứ 2 thuộc loại thứ nhất, và $\omega_c$ là tần số cắt theo radian. Nguồn Python (không có dấu trừ của phương trình 1):

import matplotlib.pyplot as plt
import scipy
import scipy.special
import numpy as np

def rotatedCosineWindow(N):  # N = horizontal size of the targeted kernel, also its vertical size, must be odd.
  return np.fromfunction(lambda y, x: np.maximum(np.cos(np.pi/2*np.sqrt(((x - (N - 1)/2)/((N - 1)/2 + 1))**2 + ((y - (N - 1)/2)/((N - 1)/2 + 1))**2)), 0), [N, N])

def circularLowpassKernelX(omega_c, N):  # omega = cutoff frequency in radians (pi is max), N = horizontal size of the kernel, also its vertical size, must be odd.
  kernel = np.fromfunction(lambda y, x: omega_c**2*(x - (N - 1)/2)*scipy.special.jv(2, omega_c*np.sqrt((x - (N - 1)/2)**2 + (y - (N - 1)/2)**2))/(2*np.pi*((x - (N - 1)/2)**2 + (y - (N - 1)/2)**2)), [N, N])
  kernel[(N - 1)//2, (N - 1)//2] = 0
  return kernel

def circularLowpassKernelY(omega_c, N):  # omega = cutoff frequency in radians (pi is max), N = horizontal size of the kernel, also its vertical size, must be odd.
  kernel = np.fromfunction(lambda y, x: omega_c**2*(y - (N - 1)/2)*scipy.special.jv(2, omega_c*np.sqrt((x - (N - 1)/2)**2 + (y - (N - 1)/2)**2))/(2*np.pi*((x - (N - 1)/2)**2 + (y - (N - 1)/2)**2)), [N, N])
  kernel[(N - 1)//2, (N - 1)//2] = 0
  return kernel

N = 41  # Horizontal size of the kernel, also its vertical size. Must be odd.
window = rotatedCosineWindow(N)

# Optional window function plot
#plt.imshow(window, vmin=-np.max(window), vmax=np.max(window), cmap='bwr')
#plt.colorbar()
#plt.show()

omega_c = np.pi/4  # Cutoff frequency in radians <= pi
kernelX = circularLowpassKernelX(omega_c, N)*window
kernelY = circularLowpassKernelY(omega_c, N)*window

# Optional kernel plot
#plt.imshow(kernelX, vmin=-np.max(kernelX), vmax=np.max(kernelX), cmap='bwr')
#plt.colorbar()
#plt.show()

Hình 1. Cửa sổ cosin xoay 2 chiều.

Hình 2. Các hạt nhân phân biệt đẳng hướng thấp ngang cửa sổ, cho các tần số cắt khác nhau $\omega_c$ cài đặt. Trên cùng: omega_c = np.pigiữa : omega_c = np.pi/4, dưới : omega_c = np.pi/16. Dấu trừ của phương trình. 1 đã bị bỏ lại. Hạt nhân dọc trông giống nhau nhưng đã được xoay 90 độ. Tổng trọng số của hạt nhân ngang và dọc, với trọng số $\cos(\phi)$ và $\sin(\phi)$ , tương ứng, đưa ra một hạt nhân phân tích cùng loại cho góc dốc $\phi$ .

Sự khác biệt của đáp ứng xung không ảnh hưởng đến băng thông, như có thể thấy bằng biến đổi Fourier nhanh 2-d (FFT) của nó, trong Python:

# Optional FFT plot
absF = np.abs(np.fft.fftshift(np.fft.fft2(circularLowpassKernelX(np.pi, N)*window)))
plt.imshow(absF, vmin=0, vmax=np.max(absF), cmap='Greys', extent=[-np.pi, np.pi, -np.pi, np.pi])
plt.colorbar()
plt.show()

Hình 3. Tầm quan trọng của FFT 2-d của $h_x$ . Trong miền tần số, sự khác biệt xuất hiện dưới dạng phép nhân của dải thông tròn phẳng bằng $\omega_x$ và bởi sự dịch chuyển pha 90 độ không thể nhìn thấy ở cường độ.

Để thực hiện tích chập cho kênh màu xanh lá cây và thu thập biểu đồ vectơ độ dốc 2 chiều, để kiểm tra trực quan, bằng Python:

import scipy.ndimage

img = plt.imread('sample.tif').astype(float)
X = scipy.ndimage.convolve(img[:,:,1], kernelX)[(N - 1)//2:-(N - 1)//2, (N - 1)//2:-(N - 1)//2]  # Green channel only
Y = scipy.ndimage.convolve(img[:,:,1], kernelY)[(N - 1)//2:-(N - 1)//2, (N - 1)//2:-(N - 1)//2]  # ...

# Optional 2-d histogram
#hist2d, xEdges, yEdges = np.histogram2d(X.flatten(), Y.flatten(), bins=199)
#plt.imshow(hist2d**(1/2.2), vmin=0, cmap='Greys')
#plt.show()
#plt.imsave('hist2d.png', plt.cm.Greys(plt.Normalize(vmin=0, vmax=hist2d.max()**(1/2.2))(hist2d**(1/2.2))))  # To save the histogram image
#plt.imsave('histkey.png', plt.cm.Greys(np.repeat([(np.arange(200)/199)**(1/2.2)], 16, 0)))

Điều này cũng cắt dữ liệu, loại bỏ các (N - 1)//2pixel từ mỗi cạnh bị ô nhiễm bởi ranh giới hình ảnh hình chữ nhật, trước khi phân tích biểu đồ.

$\pi$ $\frac{\pi}{2}$ $\frac{\pi}{4}$
$\frac{\pi}{8}$ $\frac{\pi}{16}$ $\frac{\pi}{32}$ $\frac{\pi}{64}$ - $0$
Hình 4. Biểu đồ 2 chiều của vectơ độ dốc, cho tần số cắt bộ lọc thông thấp khác nhau $\omega_c$ cài đặt. Theo thứ tự: đầu tiên với N=41: omega_c = np.pi, omega_c = np.pi/2, omega_c = np.pi/4(giống như trong Python niêm yết), omega_c = np.pi/8, omega_c = np.pi/16, sau đó: N=81: omega_c = np.pi/32, N=161: omega_c = np.pi/64. Khử nhiễu bằng cách lọc thông thấp làm sắc nét các hướng gradient theo dõi mạch trong biểu đồ.

Vector chiều dài trọng số tròn có nghĩa là hướng

Có phương pháp Yamartino để tìm hướng gió "trung bình" từ nhiều mẫu vectơ gió trong một lần đi qua các mẫu. Nó dựa trên giá trị trung bình của các đại lượng tròn , được tính là sự dịch chuyển của một cosin là tổng của các cosin được dịch chuyển bởi một lượng tròn $2\pi$ . Chúng ta có thể sử dụng một phiên bản có trọng số chiều dài vectơ của cùng một phương thức, nhưng trước tiên chúng ta cần tập hợp tất cả các hướng bằng nhau với modulo $\pi/2$ . Chúng ta có thể làm điều này bằng cách nhân góc của mỗi vectơ gradient $[X_k,Y_k]$ bằng 4, sử dụng biểu diễn số phức:

\begin{matrix} (2) & Z_{k} = \frac{(X_{k} + Y_{k} i)^{4}}{{\sqrt{X_{k}^{2} + Y_{k}^{2}}}^{3}} = \frac{X_{k}^{4} - 6 X_{k}^{2} Y_{k}^{2} + Y_{k}^{4} + (4 X_{k}^{3} Y_{k} - 4 X_{k} Y_{k}^{3}) Tôi}{{\sqrt{X_{k}^{2} + Y_{k}^{2}}}^{3}}, \end{matrix}

$Z_k = \frac{(X_k + Y_k i)^4}{\sqrt{X_k^2 + Y_k^2}^3} = \frac{X_k^4 - 6X_k^2Y_k^2 + Y_k^4 + (4X_k^3Y_k - 4X_kY_k^3)i}{\sqrt{X_k^2 + Y_k^2}^3},\tag{2}$

thỏa mãn $|Z_k| = \sqrt{X_k^2 + Y_k^2}$ và sau đó giải thích rằng các giai đoạn của $Z_k$ từ $-\pi$ đến $\pi$ đại diện cho các góc từ $-\pi/4$ đến $\pi/4$ , bằng cách chia pha trung bình tính toán cho 4:

\begin{matrix} (3) & φ = = \frac{1}{4} atan2 (\underset{k}{Σ} Tôi đang (Z_{k}), \underset{k}{Σ} Tái (Z_{k})) \end{matrix}

$\phi = \frac{1}{4}\operatorname{atan2}\left(\sum_k\operatorname{Im}(Z_k), \sum_k\operatorname{Re}(Z_k)\right)\tag{3}$

Ở đâu $\phi$ là định hướng hình ảnh ước tính.

Chất lượng của ước tính có thể được đánh giá bằng cách thực hiện một lần nữa thông qua dữ liệu và bằng cách tính khoảng cách hình tròn vuông có trọng số trung bình , $\text{MSCD}$ , giữa các pha của số phức $Z_k$ và pha trung bình tròn ước tính $4\phi$ , với $|Z_k|$ như trọng lượng:

\begin{matrix} (4) & \begin{matrix} MSCD = = \frac{\underset{k}{Σ} | Z_{k} | (1 - \cos (4 φ - atan2 (Tôi đang (Z_{k}), Tái (Z_{k}))))}{\underset{k}{Σ} | Z_{k} |} \\ = = \frac{\underset{k}{Σ} \frac{| Z_{k} |}{2} ({(\cos (4 φ) - \frac{Tái (Z_{k})}{| Z_{k} |})}^{2} + {(tội (4 φ) - \frac{Tôi đang (Z_{k})}{| Z_{k} |})}^{2})}{\underset{k}{Σ} | Z_{k} |} \\ = = \frac{\underset{k}{Σ} (| Z_{k} | - Tái (Z_{k}) \cos (4 φ) - Tôi đang (Z_{k}) tội (4 φ))}{\underset{k}{Σ} | Z_{k} |}, \end{matrix} \end{matrix}

$\begin{gather}\text{MSCD} = \frac{\sum_k|Z_k|\bigg(1 - \cos\Big(4\phi - \operatorname{atan2}\big(\operatorname{Im}(Z_k), \operatorname{Re}(Z_k)\big)\Big)\bigg)}{\sum_k|Z_k|}\\ = \frac{\sum_k\frac{|Z_k|}{2}\left(\left(\cos(4\phi) - \frac{\operatorname{Re}(Z_k)}{|Z_k|}\right)^2 + \left(\sin(4\phi) - \frac{\operatorname{Im}(Z_k)}{|Z_k|}\right)^2\right)}{\sum_k|Z_k|}\\ = \frac{\sum_k\big(|Z_k| - \operatorname{Re}(Z_k)\cos(4\phi) - \operatorname{Im}(Z_k)\sin(4\phi)\big)}{\sum_k|Z_k|},\end{gather}\tag{4}$

được giảm thiểu bởi $\phi$ tính trên mỗi phương trình. 3. Trong Python:

absZ = np.sqrt(X**2 + Y**2)
reZ = (X**4 - 6*X**2*Y**2 + Y**4)/absZ**3
imZ = (4*X**3*Y - 4*X*Y**3)/absZ**3
phi = np.arctan2(np.sum(imZ), np.sum(reZ))/4

sumWeighted = np.sum(absZ - reZ*np.cos(4*phi) - imZ*np.sin(4*phi))
sumAbsZ = np.sum(absZ)
mscd = sumWeighted/sumAbsZ

print("rotate", -phi*180/np.pi, "deg, RMSCD =", np.arccos(1 - mscd)/4*180/np.pi, "deg equivalent (weight = length)")

Dựa trên các mpmaththí nghiệm của tôi (không được hiển thị), tôi nghĩ rằng chúng ta sẽ không hết tiền số ngay cả đối với các hình ảnh rất lớn. Đối với các cài đặt bộ lọc khác nhau (được chú thích), các đầu ra được báo cáo trong khoảng từ -45 đến 45 độ:

rotate 32.29809399495655 deg, RMSCD = 17.057059965741338 deg equivalent (omega_c = np.pi)
rotate 32.07672617150525 deg, RMSCD = 16.699056648843566 deg equivalent (omega_c = np.pi/2)
rotate 32.13115293914797 deg, RMSCD = 15.217534399922902 deg equivalent (omega_c = np.pi/4, same as in the Python listing)
rotate 32.18444156018288 deg, RMSCD = 14.239347706786056 deg equivalent (omega_c = np.pi/8)
rotate 32.23705383489169 deg, RMSCD = 13.63694582160468 deg equivalent (omega_c = np.pi/16)

Lọc thông thấp mạnh có vẻ hữu ích, giảm góc tương đương với khoảng cách vuông góc trung bình (RMSCD) được tính như $\operatorname{acos}(1 - \text{MSCD})$ . Nếu không có cửa sổ cosin xoay 2 ngày, một số kết quả sẽ bị tắt theo một mức độ hoặc không (không hiển thị), điều đó có nghĩa là điều quan trọng là phải thực hiện đúng cửa sổ của các bộ lọc phân tích. Góc tương đương RMSCD không trực tiếp là ước tính sai số trong ước tính góc, nên ít hơn nhiều.

Hàm trọng lượng thay thế chiều dài hình vuông

Hãy thử bình phương chiều dài vectơ như một hàm trọng số thay thế, bằng cách:

\begin{matrix} (5) & Z_{k} = = \frac{(X_{k} + Y_{k} Tôi)^{4}}{{\sqrt{X_{k}^{2} + Y_{k}^{2}}}^{2}} = = \frac{X_{k}^{4} - 6 X_{k}^{2} Y_{k}^{2} + Y_{k}^{4} + (4 X_{k}^{3} Y_{k} - 4 X_{k} Y_{k}^{3}) Tôi}{X_{k}^{2} + Y_{k}^{2}}, \end{matrix}

$Z_k = \frac{(X_k + Y_k i)^4}{\sqrt{X_k^2 + Y_k^2}^2} = \frac{X_k^4 - 6X_k^2Y_k^2 + Y_k^4 + (4X_k^3Y_k - 4X_kY_k^3)i}{X_k^2 + Y_k^2},\tag{5}$

Trong Python:

absZ_alt = X**2 + Y**2
reZ_alt = (X**4 - 6*X**2*Y**2 + Y**4)/absZ_alt
imZ_alt = (4*X**3*Y - 4*X*Y**3)/absZ_alt
phi_alt = np.arctan2(np.sum(imZ_alt), np.sum(reZ_alt))/4

sumWeighted_alt = np.sum(absZ_alt - reZ_alt*np.cos(4*phi_alt) - imZ_alt*np.sin(4*phi_alt))
sumAbsZ_alt = np.sum(absZ_alt)
mscd_alt = sumWeighted_alt/sumAbsZ_alt

print("rotate", -phi_alt*180/np.pi, "deg, RMSCD =", np.arccos(1 - mscd_alt)/4*180/np.pi, "deg equivalent (weight = length^2)")

Trọng lượng chiều dài hình vuông làm giảm góc tương đương RMSCD khoảng một độ:

rotate 32.264713568426764 deg, RMSCD = 16.06582418749094 deg equivalent (weight = length^2, omega_c = np.pi, N = 41)
rotate 32.03693157762725 deg, RMSCD = 15.839593856962486 deg equivalent (weight = length^2, omega_c = np.pi/2, N = 41)
rotate 32.11471435914187 deg, RMSCD = 14.315371970649874 deg equivalent (weight = length^2, omega_c = np.pi/4, N = 41)
rotate 32.16968341455537 deg, RMSCD = 13.624896827482049 deg equivalent (weight = length^2, omega_c = np.pi/8, N = 41)
rotate 32.22062839958777 deg, RMSCD = 12.495324176281466 deg equivalent (weight = length^2, omega_c = np.pi/16, N = 41)
rotate 32.22385477783647 deg, RMSCD = 13.629915935941973 deg equivalent (weight = length^2, omega_c = np.pi/32, N = 81)
rotate 32.284350817263906 deg, RMSCD = 12.308297934977746 deg equivalent (weight = length^2, omega_c = np.pi/64, N = 161)

Đây có vẻ là một chức năng trọng lượng tốt hơn một chút. Tôi cũng thêm vào $\omega_c = \pi/32$ và $\omega_c = \pi/64$ . Họ sử dụng lớn hơn Ndẫn đến việc cắt xén hình ảnh khác nhau và không so sánh nghiêm ngặt các giá trị MSCD.

Biểu đồ 1-d

Lợi ích của hàm trọng lượng chiều dài hình vuông rõ ràng hơn với biểu đồ trọng số 1-d của $Z_k$ các giai đoạn. Tập lệnh Python:

# Optional histogram
hist_plain, bin_edges = np.histogram(np.arctan2(imZ, reZ), weights=np.ones(absZ.shape)/absZ.size, bins=900)
hist, bin_edges = np.histogram(np.arctan2(imZ, reZ), weights=absZ/np.sum(absZ), bins=900)
hist_alt, bin_edges = np.histogram(np.arctan2(imZ_alt, reZ_alt), weights=absZ_alt/np.sum(absZ_alt), bins=900)
plt.plot((bin_edges[:-1]+(bin_edges[1]-bin_edges[0]))*45/np.pi, hist_plain, "black")
plt.plot((bin_edges[:-1]+(bin_edges[1]-bin_edges[0]))*45/np.pi, hist, "red")
plt.plot((bin_edges[:-1]+(bin_edges[1]-bin_edges[0]))*45/np.pi, hist_alt, "blue")
plt.xlabel("angle (degrees)")
plt.show()

Hình 5. Biểu đồ trọng số được nội suy tuyến tính của các góc vectơ gradient, được bao bọc $-\pi/4\ldots\pi/4$ và có trọng số theo (theo thứ tự từ dưới lên trên ở đỉnh): không có trọng số (màu đen), chiều dài vectơ gradient (màu đỏ), hình vuông có độ dài vectơ độ dốc (màu xanh). Chiều rộng thùng là 0,1 độ. Bộ lọc bị cắt omega_c = np.pi/4, giống như trong danh sách Python. Hình dưới được phóng to ở các đỉnh.

Toán lọc ổn định

Chúng tôi đã thấy rằng phương pháp này hoạt động, nhưng sẽ tốt hơn nếu có sự hiểu biết toán học tốt hơn. Các $x$ và $y$ đáp ứng bộ lọc phân biệt được đưa ra bởi biểu thức. 1 có thể được hiểu là các hàm cơ bản để hình thành đáp ứng xung của bộ lọc phân biệt có thể điều khiển được lấy mẫu từ một vòng quay bên phải của phương trình cho $h_x[x, y]$ (Phương trình 1). Điều này dễ thấy hơn bằng cách chuyển đổi phương trình. Tọa độ 1 đến cực:

\begin{matrix} (6) & \begin{aligned} h_{x} (r, θ) = = h_{x} [r \cos (θ), r tội (θ)] & = = {\begin{cases} 0 & nếu r = = 0, \\ - \frac{ω_{c}^{2} r \cos (θ) J_{2} (ω_{c} r)}{2 π r^{2}} & nếu không thì \end{cases} \\ = = \cos (θ) f (r), \\ h_{y} (r, θ) = = h_{y} [r \cos (θ), r tội (θ)] & = = {\begin{cases} 0 & nếu r = = 0, \\ - \frac{ω_{c}^{2} r tội (θ) J_{2} (ω_{c} r)}{2 π r^{2}} & nếu không thì \end{cases} \\ = = tội (θ) f (r), \\ f (r) & = = {\begin{cases} 0 & nếu r = = 0, \\ - \frac{ω_{c}^{2} r J_{2} (ω_{c} r)}{2 π r^{2}} & nếu không thì, \end{cases} \end{aligned} \end{matrix}

$\begin{align}h_x(r, \theta) = h_x[r\cos(\theta), r\sin(\theta)] &= \begin{cases}0&\text{if }r = 0,\\-\displaystyle\frac{\omega_c^2\,r\cos(\theta)\,J_2\left(\omega_c r\right)}{2 \pi\,r^2}&\text{otherwise}\end{cases}\\ &= \cos(\theta)f(r),\\ h_y(r, \theta) = h_y[r\cos(\theta), r\sin(\theta)] &= \begin{cases}0&\text{if }r = 0,\\-\displaystyle\frac{\omega_c^2\,r\sin(\theta)\,J_2\left(\omega_c r\right)}{2 \pi\,r^2}&\text{otherwise}\end{cases}\\ &= \sin(\theta)f(r),\\ f(r) &= \begin{cases}0&\text{if }r = 0,\\-\displaystyle\frac{\omega_c^2\,r\,J_2\left(\omega_c r\right)}{2 \pi\,r^2}&\text{otherwise,}\end{cases}\end{align}\tag{6}$

trong đó cả đáp ứng xung của bộ lọc phân biệt ngang và dọc có cùng chức năng nhân tố xuyên tâm $f(r)$ . Bất kỳ phiên bản xoay $h(r, \theta, \phi)$ của $h_x(r, \theta)$ bằng góc lái $\phi$ được lấy bởi:

\begin{matrix} (7) & h (r, θ, φ) = = h_{x} (r, θ - φ) = = \cos (θ - φ) f (r) \end{matrix}

$h(r, \theta, \phi) = h_x(r, \theta - \phi) = \cos(\theta - \phi)f(r)\tag{7}$

Ý tưởng là hạt nhân lái $h(r, \theta, \phi)$ có thể được xây dựng như một tổng trọng số của $h_x(r, \theta)$ và $h_x(r, \theta)$ , với $\cos(\phi)$ và $\sin(\phi)$ như trọng lượng, và đó thực sự là trường hợp:

\begin{matrix} (số 8) & \cos (φ) h_{x} (r, θ) + tội (φ) h_{y} (r, θ) = = \cos (φ) \cos (θ) f (r) + tội (φ) tội (θ) f (r) = = \cos (θ - φ) f (r) = = h (r, θ, φ) . \end{matrix}

$\cos(\phi) h_x(r, \theta) + \sin(\phi) h_y(r, \theta) = \cos(\phi) \cos(\theta) f(r) + \sin(\phi) \sin(\theta) f(r) = \cos(\theta - \phi) f(r) = h(r, \theta, \phi).\tag{8}$

Chúng ta sẽ đi đến một kết luận tương đương nếu chúng ta nghĩ về tín hiệu được lọc thông thấp đẳng hướng là tín hiệu đầu vào và xây dựng một toán tử đạo hàm riêng đối với tọa độ đầu tiên được quay $x_\phi$ , $y_\phi$ xoay theo góc $\phi$ từ tọa độ $x$ , $y$ . (Đạo hàm có thể được coi là một hệ thống bất biến thời gian tuyến tính.) Chúng ta có:

\begin{matrix} (9) & \begin{matrix} x = = \cos (φ) x_{φ} - tội (φ) y_{φ}, \\ y = = tội (φ) x_{φ} + \cos (φ) y_{φ} \end{matrix} \end{matrix}

$\begin{gather}x = \cos(\phi)x_\phi - \sin(\phi)y_\phi,\\ y = \sin(\phi)x_\phi + \cos(\phi)y_\phi\end{gather}\tag{9}$

Sử dụng quy tắc chuỗi cho các đạo hàm riêng, toán tử đạo hàm riêng đối với $x_\phi$ có thể được biểu thị dưới dạng tổng trọng số cosin và sin của các đạo hàm riêng đối với $x$ và $y$ :

\begin{matrix} (10) & \begin{matrix} \frac{\partial}{\partial x_{φ}} = = \frac{\partial x}{\partial x_{φ}} \frac{\partial}{\partial x} + \frac{\partial y}{\partial x_{φ}} \frac{\partial}{\partial y} = = \frac{\partial (\cos (φ) x_{φ} - tội (φ) y_{φ})}{\partial x_{φ}} \frac{\partial}{\partial x} + \frac{\partial (tội (φ) x_{φ} + \cos (φ) y_{φ})}{\partial x_{φ}} \frac{\partial}{\partial y} = = \cos (φ) \frac{\partial}{\partial x} + tội (φ) \frac{\partial}{\partial y} \end{matrix} \end{matrix}

$\begin{gather}\frac{\partial}{\partial x_\phi} = \frac{\partial x}{\partial x_\phi}\frac{\partial}{\partial x} + \frac{\partial y}{\partial x_\phi}\frac{\partial}{\partial y} = \frac{\partial \big(\cos(\phi)x_\phi - \sin(\phi)y_\phi\big)}{\partial x_\phi}\frac{\partial}{\partial x} + \frac{\partial \big(\sin(\phi)x_\phi + \cos(\phi)y_\phi\big)}{\partial x_\phi}\frac{\partial}{\partial y} = \cos(\phi)\frac{\partial}{\partial x} + \sin(\phi)\frac{\partial}{\partial y}\end{gather}\tag{10}$

Một câu hỏi vẫn còn được khám phá là làm thế nào một giá trị trung bình hình tròn có trọng số phù hợp của các góc vectơ có liên quan đến góc $\phi$ về mặt nào đó, bộ lọc phân biệt định hướng "được kích hoạt nhiều nhất".

Cải tiến có thể

Để có thể cải thiện kết quả hơn nữa, độ dốc cũng có thể được tính cho các kênh màu đỏ và xanh lam, được đưa vào dưới dạng dữ liệu bổ sung trong tính toán "trung bình".

Tôi có ý tưởng mở rộng có thể của phương pháp này:

1) Sử dụng một bộ hạt nhân phân tích phân tích lớn hơn và phát hiện các cạnh thay vì phát hiện độ dốc. Điều này cần phải được chế tạo cẩn thận để các cạnh theo mọi hướng được xử lý như nhau, nghĩa là, một máy dò cạnh cho bất kỳ góc nào cũng có thể đạt được bằng một tổng số hạt nhân trực giao. Một tập hợp các hạt nhân phù hợp có thể (tôi nghĩ) có thể thu được bằng cách áp dụng các toán tử vi phân của phương trình. 11, Hình 6 (xem thêm bài Trao đổi ngăn xếp toán học của tôi ) về đáp ứng xung không gian liên tục của bộ lọc thông thấp đối xứng tròn.

\begin{matrix} (11) & \begin{matrix} lim_{h \to 0} \frac{Σ_{N = = 0}^{4 N + 1} (- 1)^{n} f (x + h \cos (\frac{2 π n}{4 N + 2}), y + h tội (\frac{2 π n}{4 N + 2}))}{h^{2 N + 1}}, \\ lim_{h \to 0} \frac{Σ_{N = = 0}^{4 N + 1} (- 1)^{n} f (x + h tội (\frac{2 π n}{4 N + 2}), y + h \cos (\frac{2 π n}{4 N + 2}))}{h^{2 N + 1}} \end{matrix} \end{matrix}

$\begin{gather}\lim_{h\to 0}\frac{\sum_{N=0}^{4N + 1} (-1)^n f\bigg(x + h\cos\left(\frac{2\pi n}{4N + 2}\right), y + h\sin\left(\frac{2\pi n}{4N + 2}\right)\bigg)}{h^{2N + 1}},\\ \lim_{h\to 0}\frac{\sum_{N=0}^{4N + 1} (-1)^n f\bigg(x + h\sin\left(\frac{2\pi n}{4N + 2}\right), y + h\cos\left(\frac{2\pi n}{4N + 2}\right)\bigg)}{h^{2N + 1}}\end{gather}\tag{11}$

Hình 6. Dirac delta vị trí tương đối trong các toán tử vi sai để xây dựng các máy dò cạnh bậc cao hơn.

2) Việc tính giá trị trung bình (có trọng số) của đại lượng tròn có thể được hiểu là tổng các cosin có cùng tần số được dịch chuyển bởi các mẫu của đại lượng (và được chia theo trọng số) và tìm đỉnh của hàm kết quả. Nếu các sóng hài được dịch chuyển và chia tỷ lệ tương tự của cosin bị dịch chuyển, với biên độ tương đối được chọn cẩn thận, được thêm vào hỗn hợp, tạo thành một hạt làm mịn sắc nét hơn, thì có thể xuất hiện nhiều đỉnh trong tổng và đỉnh có giá trị lớn nhất. Với một hỗn hợp hài hòa phù hợp, điều đó sẽ mang lại một loại trung bình cục bộ mà phần lớn bỏ qua các ngoại lệ ra khỏi đỉnh chính của phân phối.

Cách tiếp cận khác

Cũng có thể kết hợp hình ảnh theo góc $\phi$ và góc $\phi + \pi/2$ xoay các hạt nhân "cạnh dài" và để tính bình phương trung bình của các pixel của hai hình ảnh được chập. Góc $\phi$ mà tối đa hóa bình phương trung bình sẽ được báo cáo. Cách tiếp cận này có thể đưa ra một sàng lọc cuối cùng tốt cho việc tìm hướng định hướng hình ảnh, bởi vì thật nguy hiểm khi tìm kiếm góc hoàn chỉnh $\phi$ không gian ở các bước lớn.

Một cách tiếp cận khác là các phương pháp không cục bộ, như các vùng tương tự xa tương quan chéo, có thể áp dụng nếu bạn biết rằng có các dấu vết ngang hoặc dọc dài hoặc các tính năng lặp lại nhiều lần theo chiều ngang hoặc chiều dọc.

— Olli Niemitalo
nguồn

Làm thế nào chính xác kết quả bạn nhận được?

— Royi

@Royi Có lẽ khoảng 0,1 độ.

— Olli Niemitalo

@OlliNiemitalo khá ấn tượng, với độ phân giải hạn chế!

— Marcus Müller

@OlliNiemitalo nói về ấn tượng: này. câu trả lời. Là. cái đó. từ ngữ. rất. Định nghĩa.

— Marcus Müller

@ MarcusMüller Cảm ơn Marcus, tôi dự đoán phần mở rộng đầu tiên cũng rất thú vị.

— Olli Niemitalo

Có một mẹo DSP tương tự ở đây, nhưng tôi không nhớ chính xác các chi tiết.

Tôi đọc về nó ở đâu đó, một thời gian trước đây. Nó phải làm với việc tìm ra các mẫu vải phù hợp bất kể định hướng. Vì vậy, bạn có thể muốn nghiên cứu về điều đó.

Lấy một mẫu vòng tròn. Làm các khoản tiền dọc theo nan hoa của vòng tròn để có được một hồ sơ chu vi. Sau đó, họ đã thực hiện một DFT về điều đó (rốt cuộc nó đã được thông tư). Xé thông tin pha (làm cho nó định hướng độc lập) và so sánh.

Sau đó, họ có thể biết liệu hai loại vải có cùng một mẫu.

Vấn đề của bạn là tương tự.

Dường như với tôi, mà không cần thử trước, các đặc điểm của hồ sơ DFT trước sẽ tiết lộ định hướng. Làm độ lệch chuẩn dọc theo nan hoa thay vì tổng sẽ hoạt động tốt hơn, có thể cả hai.

Bây giờ, nếu bạn có một hình ảnh tham chiếu định hướng, bạn có thể sử dụng kỹ thuật của họ.

Ced

Yêu cầu chính xác của bạn là khá nghiêm ngặt.

Tôi đã cho điều này một whack. Lấy tổng các giá trị tuyệt đối của sự khác biệt giữa hai điểm tiếp theo dọc theo cách nói cho mỗi màu.

Dưới đây là một biểu đồ xung quanh chu vi. Giá trị của bạn được vẽ với các điểm đánh dấu màu trắng.

Bạn có thể thấy nó, nhưng tôi không nghĩ rằng nó sẽ hiệu quả với bạn. Lấy làm tiếc.

Báo cáo tiến độ: Một số

Tôi đã quyết định về một quá trình ba bước.

1) Tìm điểm đánh giá.

2) Đo lường thô

3) Đo lường tốt

Hiện tại, bước đầu tiên là sự chú ý của người dùng. Nó sẽ tự động tương thích, nhưng tôi không bận tâm. Tôi có một bản thảo thô của bước thứ hai. Có một số điều chỉnh tôi muốn thử. Cuối cùng, tôi có một vài ứng cử viên cho bước thứ ba sẽ thực hiện thử nghiệm để xem cái nào hoạt động tốt nhất.

Tin tốt là nó được chiếu sáng nhanh. Nếu mục đích duy nhất của bạn là làm cho mức độ hình ảnh trông trên một trang web, thì dung sai của bạn quá nghiêm ngặt và phép đo thô phải đủ chính xác.

Đây là phép đo thô. Mỗi pixel khoảng 0,6 độ. (Chỉnh sửa, thực sự là 0,3)

Báo cáo tiến độ: Có thể nhận được kết quả tốt

Hầu hết không tốt như vậy, nhưng chúng rẻ (và khá địa phương) và việc tìm kiếm các điểm để có được đọc tốt là dễ dàng ..... đối với một con người. Lực lượng vũ phu nên làm việc tốt cho một chương trình.

Các kết quả có thể được cải thiện nhiều, đây là một thử nghiệm cơ bản đơn giản. Tôi chưa sẵn sàng để giải thích, cũng không đăng mã, nhưng màn hình này không được photoshop.

Báo cáo tiến độ: Mã được đăng, tôi đã hoàn thành việc này trong một thời gian.

Ảnh chụp màn hình này là chương trình làm việc trên ảnh chụp 45 độ của Marcus.

Các kênh màu được xử lý độc lập.

Một điểm được chọn là trung tâm quét.

Một đường kính được quét qua 180 độ ở các góc riêng biệt

Ở mỗi góc, "độ biến động" được đo trên đường kính. Một dấu vết được thực hiện cho mỗi kênh thu thập mẫu. Giá trị mẫu là một phép nội suy tuyến tính của bốn giá trị góc của bất kỳ ô vuông nào mà điểm mẫu nằm trên.

Đối với mỗi dấu vết kênh

Các mẫu được nhân với chức năng cửa sổ VonHann

Một đường chuyền Smooth / Dif được thực hiện trên các mẫu

RMS của sự khác biệt được sử dụng như một biện pháp biến động

Các biểu đồ hàng thấp hơn là:

Đầu tiên là quét từ 0 đến 180 độ, mỗi pixel là 0,5 độ. Thứ hai là quét xung quanh góc đã chọn, mỗi pixel là 0,1 độ. Thứ ba là quét xung quanh góc đã chọn, mỗi pixel là 0,01 độ. Thứ tư là đường cong vi sai

Lựa chọn ban đầu là độ biến động trung bình tối thiểu của ba kênh. Điều này sẽ gần, nhưng thường không phải trên, góc tốt nhất. Sự đối xứng tại máng là một chỉ số tốt hơn mức tối thiểu. Một parabola phù hợp nhất trong khu phố đó sẽ mang lại một câu trả lời rất tốt.

Mã nguồn (trong Gambas, PPA gambas-team / gambas3) có thể được tìm thấy tại:

https://forum.gambas.one/viewtopic.php?f=4&t=707

Đây là một tệp zip thông thường, vì vậy bạn không cần phải cài đặt Gambas để xem nguồn. Các tệp nằm trong thư mục con ".src".

Loại bỏ cửa sổ VonHann mang lại độ chính xác cao hơn vì nó có hiệu quả kéo dài dấu vết, nhưng thêm sự chao đảo. Có lẽ một VonHann đôi sẽ tốt hơn vì trung tâm là không quan trọng và khởi phát nhanh hơn "khi teeter-totter chạm đất" sẽ được phát hiện. Độ chính xác có thể dễ dàng được cải thiện khi tôi tăng chiều dài theo dõi khi hình ảnh cho phép (Có, đó là tự động tương thích). Một chức năng cửa sổ tốt hơn, chân thành?

Các biện pháp tôi đã thực hiện ở cài đặt hiện tại xác nhận giá trị 3.19 +/-. 03 ish.

Đây chỉ là công cụ đo lường. Có một số chiến lược tôi có thể nghĩ ra để áp dụng nó vào hình ảnh. Điều đó, như họ nói, là một bài tập cho người đọc. Hoặc trong trường hợp này, OP. Tôi sẽ cố gắng sau này.

Có phòng đầu để cải tiến cả thuật toán và chương trình, nhưng chúng thực sự hữu ích.

Đây là cách nội suy tuyến tính hoạt động

'---- Phần số

        x = Tầng (rx)
        y = Tầng (ry)

'---- Phần phân số

        fx = rx - x
        fy = ry - y

        gx = 1,0 - fx
        gy = 1.0 - fy

'---- Bình quân gia quyền

        vtl = ArgValues [x, y] * gx * gy 'Trên cùng bên trái
        vtr = ArgValues [x + 1, y] * fx * gy 'Trên cùng bên phải
        vbl = ArgValues [x, y + 1] * gx * fy 'Dưới cùng bên trái
        vbr = ArgValues [x + 1, y + 1] * fx * fy 'Độ cứng đáy

        v = vtl + vtr + vbl + vbr

Bất cứ ai cũng biết tên thông thường cho điều đó?

— Cedron Dawg
nguồn

này, bạn không cần phải xin lỗi vì điều gì đó là một cách tiếp cận rất thông minh và có thể cực kỳ hữu ích cho ai đó có vấn đề tương tự sẽ đến đây sau! +1

— Marcus Müller

@BarsMonster, tôi đang làm tốt. Bạn sẽ muốn cài đặt Gambas (PPA: gambas-team / gambas3) trên hộp Linux của bạn. (Có khả năng, bạn cũng vậy Marcus và Olli, nếu bạn có thể.) Tôi đang làm việc trên một chương trình không chỉ giải quyết vấn đề này mà còn đóng vai trò là cơ sở tốt cho các tác vụ xử lý ảnh khác.

— Cedron Dawg

Nhìn về phía trước!

— Marcus Müller

@CedronDawg đó được gọi là phép nội suy song tuyến, đây là lý do tại sao , cũng chỉ ra một triển khai thay thế.

— Olli Niemitalo

@ OlliNiemitalo, Cảm ơn Olli. Trong tình huống này, tôi không nghĩ đi xe đạp sẽ cải thiện kết quả so với song tuyến, thực tế, nó thậm chí có thể gây bất lợi. Sau đó, tôi sẽ chơi xung quanh với các số liệu biến động khác nhau dọc theo đường kính và chức năng cửa sổ có hình dạng khác nhau. Tại thời điểm này, tôi đang nghĩ đến việc sử dụng VonHann ở hai đầu đường kính như mái chèo hoặc "ghế teeter-totter chạm bùn". Đáy phẳng trong đường cong là nơi mà người thợ rèn chưa có mặt đất (cạnh). Một nửa giữa hai góc là một đọc tốt. Các cài đặt hiện tại tốt đến dưới 0,1 độ,

— Cedron Dawg

Hiệu suất khá cao, nhưng sẽ giúp bạn có được độ chính xác như mong muốn:

Cạnh phát hiện hình ảnh
Chuyển đổi thành một không gian nơi bạn có đủ pixel cho độ chính xác mong muốn.
Vì có đủ đường trực giao; hình ảnh trong không gian chòi sẽ chứa cực đại nằm trên hai dòng. Đây là những dễ dàng phát hiện và cung cấp cho bạn góc mong muốn.

— RobAu
nguồn

Thật tuyệt, chính xác là cách tiếp cận của tôi: Tôi hơi buồn vì tôi đã không nhìn thấy nó trước khi tôi đi tàu và do đó không kết hợp nó trong câu trả lời của tôi. +1 rõ ràng!

— Marcus Müller

Tôi đã đi trước và về cơ bản điều chỉnh ví dụ biến đổi Hough của opencv với trường hợp sử dụng của bạn. Ý tưởng này rất hay, nhưng vì hình ảnh của bạn đã có nhiều cạnh do tính chất sắc nét của nó, việc phát hiện cạnh không nên có nhiều lợi ích.

Vì vậy, những gì tôi đã làm ở trên đã nói ví dụ là

Bỏ qua phát hiện cạnh
phân tách hình ảnh đầu vào của bạn thành các kênh màu và xử lý chúng riêng biệt
đếm số lần xuất hiện của các đường trong một góc cụ thể (sau khi định lượng các góc và lấy chúng theo modulo 90 °, vì bạn có nhiều góc vuông)
kết hợp các quầy của các kênh màu
sửa các phép quay này

Những gì bạn có thể làm để cải thiện hơn nữa chất lượng ước tính (như bạn sẽ thấy bên dưới, dự đoán hàng đầu không đúng - thứ hai là) có thể sẽ chuyển đổi hình ảnh thành hình ảnh thang độ xám thể hiện sự khác biệt thực tế giữa các khác nhau vật liệu tốt nhất - rõ ràng, các kênh RGB không phải là tốt nhất. Bạn là chuyên gia về chất bán dẫn, vì vậy hãy tìm cách kết hợp các kênh màu theo cách tối đa hóa sự khác biệt giữa kim loại hóa và silicon.

Máy tính xách tay jupyter của tôi ở đây . Xem kết quả dưới đây.

Để tăng độ phân giải góc, tăng QUANT_STEPbiến và độ chính xác góc trong hough_transformcuộc gọi. Tôi đã không làm thế, vì tôi muốn mã này được viết trong <20 phút và do đó tôi không muốn đầu tư một phút vào tính toán.

import cv2
import numpy
from matplotlib import pyplot
import collections

QUANT_STEPS = 360*2

def quantized_angle(line, quant = QUANT_STEPS):
    theta = line[0][1]
    return numpy.round(theta / numpy.pi / 2 * QUANT_STEPS) / QUANT_STEPS * 360 % 90

def detect_rotation(monochromatic_img):
    # edges = cv2.Canny(monochromatic_img, 50, 150, apertureSize = 3) #play with these parameters
    lines = cv2.HoughLines(monochromatic_img, #input
                           1, # rho resolution [px]
                           numpy.pi/180, # angular resolution [radian]
                           200) # accumulator threshold – higher = fewer candidates
    counter = collections.Counter(quantized_angle(line) for line in lines)
    return counter

img = cv2.imread("/tmp/HIKRe.jpg") #Image directly as grabbed from imgur.com
total_count = collections.Counter()
for channel in range(img.shape[-1]):
    total_count.update(detect_rotation(img[:,:,channel]))

most_common = total_count.most_common(5)

for angle,_ in most_common:
    pyplot.figure(figsize=(8,6), dpi=100)
    pyplot.title(f"{angle:.3f}°")
    rotation = cv2.getRotationMatrix2D((img.shape[0]/2, img.shape[1]/2), -angle, 1)
    pyplot.imshow(cv2.warpAffine(img, rotation, img.shape[:2]))

— Marcus Müller
nguồn

Đây là một bước đi trong phần mở rộng được đề xuất đầu tiên của câu trả lời trước đây của tôi .

Bộ lọc giới hạn đối xứng vòng tròn lý tưởng

Chúng tôi xây dựng một ngân hàng trực giao gồm bốn bộ lọc được giới hạn trong một vòng tròn bán kính $\omega_c$ trên mặt phẳng tần số. Các đáp ứng xung của các bộ lọc này có thể được kết hợp tuyến tính để tạo thành các hạt nhân phát hiện cạnh định hướng. Một tập hợp các đáp ứng xung bộ lọc trực giao được chuẩn hóa tùy ý có được bằng cách áp dụng hai cặp toán tử vi phân "giống như quả bóng bãi biển" đầu tiên cho đáp ứng xung không gian liên tục của đáp ứng xung bộ lọc lý tưởng đối xứng vòng tròn $h(x,y)$ :

\begin{matrix} (1) & h (x, y) = = \frac{ω_{c}}{2 π \sqrt{x^{2} + y^{2}}} J_{1} (ω_{c} \sqrt{x^{2} + y^{2}}) \end{matrix}

$h(x,y) = \frac{\omega_c}{2\pi \sqrt{x^2 + y^2} } J_1 \big( \omega_c \sqrt{x^2 + y^2} \big)\tag{1}$

\begin{matrix} (2) & \begin{aligned} h_{0 x} (x, y) & α \frac{d}{d x} h (x, y), \\ h_{0 y} (x, y) & α \frac{d}{d y} h (x, y), \\ h_{1 x} (x, y) & α ({(\frac{d}{d x})}^{3} - 3 \frac{d}{d x} {(\frac{d}{d y})}^{2}) h (x, y), \\ h_{1 y} (x, y) & α ({(\frac{d}{d y})}^{3} - 3 \frac{d}{d y} {(\frac{d}{d x})}^{2}) h (x, y) \end{aligned} \end{matrix}

$\begin{align}h_{0x}(x, y) &\propto \frac{d}{dx}h(x, y),\\ h_{0y}(x, y) &\propto \frac{d}{dy}h(x, y),\\ h_{1x}(x, y) &\propto \left(\left(\frac{d}{dx}\right)^3-3\frac{d}{dx}\left(\frac{d}{dy}\right)^2\right)h(x, y),\\ h_{1y}(x, y) &\propto \left(\left(\frac{d}{dy}\right)^3-3\frac{d}{dy}\left(\frac{d}{dx}\right)^2\right)h(x, y)\end{align}\tag{2}$

\begin{matrix} (3) & \begin{aligned} h_{0 x} (x, y) & = = {\begin{cases} 0 & nếu x = = y = = 0, \\ - \frac{ω_{c}^{2} x J_{2} (ω_{c} \sqrt{x^{2} + y^{2}})}{2 π (x^{2} + y^{2})} & nếu không thì, \end{cases} \\ h_{0 y} (x, y) & = = h_{0 x} [y, x], \\ h_{1 x} (x, y) & = = {\begin{cases} 0 & nếu x = = y = = 0, \\ \frac{\begin{array}{l} (ω_{c} x (3 y^{2} - x^{2}) (J_{0} (ω_{c} \sqrt{x^{2} + y^{2}}) ω_{c} \sqrt{x^{2} + y^{2}} (ω_{c}^{2} x^{2} + ω_{c}^{2} y^{2} - 24) \\ - số 8 J_{1} (ω_{c} \sqrt{x^{2} + y^{2}}) (ω_{c}^{2} x^{2} + ω_{c}^{2} y^{2} - 6))) \end{array}}{2 π (x^{2} + y^{2})^{7 / 2}} & nếu không thì, \end{cases} \\ h_{1 y} (x, y) & = = h_{1 x} [y, x], \end{aligned} \end{matrix}

$\begin{align}h_{0x}(x, y) &= \begin{cases}0&\text{if }x = y = 0,\\-\displaystyle\frac{\omega_c^2\,x\,J_2\left(\omega_c\sqrt{x^2 + y^2}\right)}{2 \pi\,(x^2 + y^2)}&\text{otherwise,}\end{cases}\\ h_{0y}(x, y) &= h_{0x}[y, x],\\ h_{1x}(x, y) &= \begin{cases}0&\text{if }x = y = 0,\\\frac{\begin{array}{l}\Big(ω_cx(3y^2 - x^2)\big(J_0\left(ω_c\sqrt{x^2 + y^2}\right)ω_c\sqrt{x^2 + y^2}(ω_c^2x^2 + ω_c^2y^2 - 24)\\ - 8J_1\left(ω_c\sqrt{x^2 + y^2}\right)(ω_c^2x^2 + ω_c^2y^2 - 6)\big)\Big)\end{array}}{2π(x^2 + y^2)^{7/2}}&\text{otherwise,}\end{cases}\\ h_{1y}(x, y) &= h_{1x}[y, x],\end{align}\tag{3}$

Ở đâu $J_\alpha$ là một hàm Bessel của loại thứ tự đầu tiên $\alpha$ và $\propto$ có nghĩa là "tỷ lệ thuận với". Tôi đã sử dụng các truy vấn Wolfram Alpha ( (ᵈ / dx) ³ ; / dx ; / dx (ᵈ / dy) ² ) để thực hiện phân biệt và đơn giản hóa kết quả.

Hạt nhân cắt ngắn trong Python:

import matplotlib.pyplot as plt
import scipy
import scipy.special
import numpy as np

def h0x(x, y, omega_c):
  if x == 0 and y == 0:
    return 0
  return -omega_c**2*x*scipy.special.jv(2, omega_c*np.sqrt(x**2 + y**2))/(2*np.pi*(x**2 + y**2))

def h1x(x, y, omega_c):
  if x == 0 and y == 0:
    return 0
  return omega_c*x*(3*y**2 - x**2)*(scipy.special.j0(omega_c*np.sqrt(x**2 + y**2))*omega_c*np.sqrt(x**2 + y**2)*(omega_c**2*x**2 + omega_c**2*y**2 - 24) - 8*scipy.special.j1(omega_c*np.sqrt(x**2 + y**2))*(omega_c**2*x**2 + omega_c**2*y**2 - 6))/(2*np.pi*(x**2 + y**2)**(7/2))

def rotatedCosineWindow(N):  # N = horizontal size of the targeted kernel, also its vertical size, must be odd.
  return np.fromfunction(lambda y, x: np.maximum(np.cos(np.pi/2*np.sqrt(((x - (N - 1)/2)/((N - 1)/2 + 1))**2 + ((y - (N - 1)/2)/((N - 1)/2 + 1))**2)), 0), [N, N])

def circularLowpassKernel(omega_c, N):  # omega = cutoff frequency in radians (pi is max), N = horizontal size of the kernel, also its vertical size, must be odd.
  kernel = np.fromfunction(lambda x, y: omega_c*scipy.special.j1(omega_c*np.sqrt((x - (N - 1)/2)**2 + (y - (N - 1)/2)**2))/(2*np.pi*np.sqrt((x - (N - 1)/2)**2 + (y - (N - 1)/2)**2)), [N, N])
  kernel[(N - 1)//2, (N - 1)//2] = omega_c**2/(4*np.pi)
  return kernel

def prototype0x(omega_c, N):  # omega = cutoff frequency in radians (pi is max), N = horizontal size of the kernel, also its vertical size, must be odd.
  kernel = np.zeros([N, N])
  for y in range(N):
    for x in range(N):
      kernel[y, x] = h0x(x - (N - 1)/2, y - (N - 1)/2, omega_c)
  return kernel

def prototype0y(omega_c, N):  # omega = cutoff frequency in radians (pi is max), N = horizontal size of the kernel, also its vertical size, must be odd.
  return prototype0x(omega_c, N).transpose()

def prototype1x(omega_c, N):  # omega = cutoff frequency in radians (pi is max), N = horizontal size of the kernel, also its vertical size, must be odd.
  kernel = np.zeros([N, N])
  for y in range(N):
    for x in range(N):
      kernel[y, x] = h1x(x - (N - 1)/2, y - (N - 1)/2, omega_c)
  return kernel

def prototype1y(omega_c, N):  # omega = cutoff frequency in radians (pi is max), N = horizontal size of the kernel, also its vertical size, must be odd.
  return prototype1x(omega_c, N).transpose()

N = 321  # Horizontal size of the kernel, also its vertical size. Must be odd.
window = rotatedCosineWindow(N)

# Optional window function plot
#plt.imshow(window, vmin=-np.max(window), vmax=np.max(window), cmap='bwr')
#plt.colorbar()
#plt.show()

omega_c = np.pi/8  # Cutoff frequency in radians <= pi
lowpass = circularLowpassKernel(omega_c, N)
kernel0x = prototype0x(omega_c, N)
kernel0y = prototype0y(omega_c, N)
kernel1x = prototype1x(omega_c, N)
kernel1y = prototype1y(omega_c, N)

# Optional kernel image save
plt.imsave('lowpass.png', plt.cm.bwr(plt.Normalize(vmin=-lowpass.max(), vmax=lowpass.max())(lowpass)))
plt.imsave('kernel0x.png', plt.cm.bwr(plt.Normalize(vmin=-kernel0x.max(), vmax=kernel0x.max())(kernel0x)))
plt.imsave('kernel0y.png', plt.cm.bwr(plt.Normalize(vmin=-kernel0y.max(), vmax=kernel0y.max())(kernel0y)))
plt.imsave('kernel1x.png', plt.cm.bwr(plt.Normalize(vmin=-kernel1x.max(), vmax=kernel1x.max())(kernel1x)))
plt.imsave('kernel1y.png', plt.cm.bwr(plt.Normalize(vmin=-kernel1y.max(), vmax=kernel1y.max())(kernel1y)))
plt.imsave('kernelkey.png', plt.cm.bwr(np.repeat([(np.arange(321)/320)], 16, 0)))

Hình 1. Biểu đồ tỷ lệ 1: 1 được ánh xạ màu của đáp ứng xung bộ lọc giới hạn băng đối xứng, với tần số cắt $\omega_c = \pi/8$ . Phím màu: xanh dương: âm tính, trắng: không, đỏ: tối đa.

Hình 2. Các sơ đồ tỷ lệ 1: 1 được ánh xạ màu của các phản ứng xung được lấy mẫu của các bộ lọc trong ngân hàng bộ lọc, với tần suất cắt $\omega_c = \pi/8$ , theo thứ tự: $h_{0x}$ , $h_{0y}$ , $h_{1x}$ , $h_{0y}$ . Phím màu: xanh dương: tối thiểu, trắng: không, đỏ: tối đa.

Máy dò cạnh định hướng có thể được xây dựng như một khoản tiền có trọng số trong số này. Trong Python (tiếp theo):

composite = kernel0x-4*kernel1x
plt.imsave('composite0.png', plt.cm.bwr(plt.Normalize(vmin=-composite.max(), vmax=composite.max())(composite)))
plt.imshow(composite, vmin=-np.max(composite), vmax=np.max(composite), cmap='bwr')
plt.colorbar()
plt.show()

composite = (kernel0x+kernel0y) + 4*(kernel1x+kernel1y)
plt.imsave('composite45.png', plt.cm.bwr(plt.Normalize(vmin=-composite.max(), vmax=composite.max())(composite)))
plt.imshow(composite, vmin=-np.max(composite), vmax=np.max(composite), cmap='bwr')
plt.colorbar()
plt.show()

Hình 3. Các hạt nhân phát hiện cạnh có hướng được xây dựng dưới dạng tổng trọng số của các hạt nhân của Hình 2. Phím màu: xanh dương: tối thiểu, trắng: không, đỏ: tối đa.

Các bộ lọc của Hình 3 nên được điều chỉnh tốt hơn cho các cạnh liên tục, so với các bộ lọc gradient (hai bộ lọc đầu tiên của Hình 2).

Bộ lọc Gaussian

Các bộ lọc của Hình 2 có rất nhiều dao động do giới hạn băng tần nghiêm ngặt. Có lẽ một điểm nhìn tốt hơn sẽ là một hàm Gaussian, như trong các bộ lọc đạo hàm Gaussian. Một cách tương đối, chúng dễ dàng hơn nhiều để xử lý toán học. Hãy thử điều đó thay vào đó. Chúng tôi bắt đầu với định nghĩa đáp ứng xung của bộ lọc "low-pass" Gaussian:

\begin{matrix} (4) & h (x, y, σ) = = \frac{e^{- \frac{x^{2} + y^{2}}{2 σ^{2}}}}{2 π σ^{2}} . \end{matrix}

$h(x, y, \sigma) = \frac{e^{-\displaystyle\frac{x^2 + y^2}{2 \sigma^2}}}{2\pi \sigma^2}.\tag{4}$

Chúng tôi áp dụng các toán tử của phương trình. 2 đến $h(x, y, \sigma)$ và chuẩn hóa từng bộ lọc $h_{..}$ bởi:

\begin{matrix} (5) & \int_{- \infty}^{\infty} \int_{- \infty}^{\infty} h_{. .} (x, y, σ)^{2} d x d y = = 1. \end{matrix}

$\int_{-\infty}^{\infty}\int_{-\infty}^{\infty}h_{..}(x, y, \sigma)^2\,dx\,dy = 1.\tag{5}$

\begin{matrix} (6) & \begin{aligned} h_{0 x} (x, y, σ) & = = 2 \sqrt{2 π} σ^{2} \frac{d}{d x} h (x, y, σ) = = - \frac{\sqrt{2}}{\sqrt{π} σ^{2}} x e^{- \frac{x^{2} + y^{2}}{2 σ^{2}}}, \\ h_{0 y} (x, y, σ) & = = h_{0 x} (y, x, σ), \\ h_{1 x} (x, y, σ) & = = \frac{2 \sqrt{3 π} σ^{4}}{3} ({(\frac{d}{d x})}^{3} - 3 \frac{d}{d x} {(\frac{d}{d y})}^{2}) h (x, y, σ) = = - \frac{\sqrt{3}}{3 \sqrt{π} σ^{4}} (x^{3} - 3 x y^{2}) e^{- \frac{x^{2} + y^{2}}{2 σ^{2}}}, \\ h_{1 y} (x, y, σ) & = = h_{1 x} (y, x, σ) . \end{aligned} \end{matrix}

$\begin{align}h_{0x}(x, y, \sigma) &= 2\sqrt{2\pi}σ^2 \frac{d}{dx}h(x, y, \sigma) = - \frac{\sqrt{2}}{\sqrt{\pi}σ^2} x e^{-\displaystyle\frac{x^2 + y^2}{2σ^2}},\\ h_{0y}(x, y, \sigma) &= h_{0x}(y, x, \sigma),\\ h_{1x}(x, y, \sigma) &= \frac{2\sqrt{3\pi}σ^4}{3}\left(\left(\frac{d}{dx}\right)^3-3\frac{d}{dx}\left(\frac{d}{dy}\right)^2\right)h(x, y, \sigma) = - \frac{\sqrt{3}}{3\sqrt{\pi}σ^4} (x^3 - 3xy^2) e^{-\displaystyle\frac{x^2 + y^2}{2σ^2}},\\ h_{1y}(x, y, \sigma) &= h_{1x}(y, x, \sigma).\end{align}\tag{6}$

Chúng tôi muốn xây dựng từ đó, như tổng trọng số của chúng, đáp ứng xung của bộ lọc phát hiện cạnh dọc tối đa hóa tính đặc hiệu $S$ đó là độ nhạy trung bình đối với cạnh dọc so với dịch chuyển cạnh có thể $s$ liên quan đến độ nhạy trung bình trên các góc quay cạnh có thể $\beta$ và dịch chuyển cạnh có thể $s$ :

\begin{matrix} (7) & S = = \frac{2 π \int_{- \infty}^{\infty} (\int_{- \infty}^{\infty} (\int_{- \infty}^{S} h_{x} (x, y, σ) d x - \int_{S}^{\infty} h_{x} (x, y, σ) d x) d y)^{2} d S}{(\int_{- π}^{π} \int_{- \infty}^{\infty} (\int_{- \infty}^{\infty} (\int_{- \infty}^{S} h_{x} (\cos (β) x - tội (β) y, tội (β) x + \cos (β) y) d x - \int_{S}^{\infty} h_{x} (\cos (β) x - tội (β) y, tội (β) x + \cos (β) y) d x) d y)^{2} d S d β)} . \end{matrix}

$S = \frac{2\pi\displaystyle\int_{-\infty}^{\infty}\Bigg(\int_{-\infty}^{\infty}\bigg(\int_{-\infty}^{s}h_x(x, y, \sigma)dx - \int_{s}^{\infty}h_x(x, y, \sigma)dx\bigg)dy\Bigg)^2ds} {\Bigg(\displaystyle\int_{-\pi}^{\pi}\int_{-\infty}^{\infty}\bigg(\int_{-\infty}^{\infty}\Big(\int_{-\infty}^{s}h_x\big(\cos(\beta)x- \sin(\beta)y, \sin(\beta)x + \cos(\beta)y\big)dx \\- \displaystyle\int_{s}^{\infty}h_x\big(\cos(\beta)x - \sin(\beta)y, \sin(\beta)x + \cos(\beta)y\big)dx\Big)dy\bigg)^2ds\,d\beta\Bigg)}.\tag{7}$

Chúng ta chỉ cần một tổng số có trọng số là $h_{0x}$ với phương sai $\sigma^2$ và $h_{1x}$ với phương sai tối ưu. Hóa ra $S$ được tối đa hóa bởi một phản ứng thúc đẩy:

\begin{matrix} (số 8) & \begin{aligned} h_{x} (x, y, σ) & = = \frac{\sqrt{7625 - 2440 \sqrt{5}}}{61} h_{0 x} (x, y, σ) - \frac{2 \sqrt{610 \sqrt{5} - 976}}{61} h_{1 x} (x, y, \sqrt{5} σ) \\ = = - \frac{\sqrt{(15250 - 4880 \sqrt{5}}}{61 \sqrt{π} σ^{2}} x e^{- \frac{x^{2} + y^{2}}{2 σ^{2}}} + \frac{\sqrt{1830 \sqrt{5} - 2928}}{4575 \sqrt{π} σ^{4}} (2 x^{3} - 6 x y^{2}) e^{- \frac{x^{2} + y^{2}}{10 σ^{2}}} \\ = = \frac{2 \sqrt{π} σ^{2} \sqrt{15250 - 4880 \sqrt{5}}}{61} \frac{d}{d x} h (x, y, σ) - \frac{100 \sqrt{π} σ^{4} \sqrt{1830 \sqrt{5} - 2928}}{183} ({(\frac{d}{d x})}^{3} - 3 \frac{d}{d x} {(\frac{d}{d y})}^{2}) h (x, y, \sqrt{5} σ) \\ \approx 3.8275359956049814 σ^{2} \frac{d}{d x} h (x, y, σ) - 33.044650082417731 σ^{4} ({(\frac{d}{d x})}^{3} - 3 \frac{d}{d x} {(\frac{d}{d y})}^{2}) h (x, y, \sqrt{5} σ), \end{aligned} \end{matrix}

$\begin{align}h_x(x, y, \sigma) &= \frac{\sqrt{7625 - 2440\sqrt{5}}}{61} h_{0x}(x, y, \sigma) - \frac{2\sqrt{610\sqrt{5} - 976}}{61} h_{1x}(x, y, \sqrt{5}\sigma)\\ &= - \frac{\sqrt{(15250 - 4880\sqrt{5}}}{61\sqrt{\pi}σ^2}xe^{-\displaystyle\frac{x^2 + y^2}{2σ^2}} + \frac{\sqrt{1830\sqrt{5} - 2928}}{4575 \sqrt{\pi} σ^4}(2x^3 - 6xy^2)e^{-\displaystyle\frac{x^2 + y^2}{10 σ^2}}\\ &= \frac{2\sqrt{\pi}σ^2\sqrt{15250 - 4880\sqrt{5}}}{61}\frac{d}{dx}h(x, y, \sigma) - \frac{100\sqrt{\pi}σ^4\sqrt{1830\sqrt{5} - 2928}}{183}\left(\left(\frac{d}{dx}\right)^3-3\frac{d}{dx}\left(\frac{d}{dy}\right)^2\right)h(x, y,\sqrt{5}\sigma)\\ &\approx 3.8275359956049814\,\sigma^2\frac{d}{dx}h(x, y, \sigma) - 33.044650082417731\,\sigma^4\left(\left(\frac{d}{dx}\right)^3-3\frac{d}{dx}\left(\frac{d}{dy}\right)^2\right)h(x, y,\sqrt{5}\sigma),\end{align}\tag{8}$

cũng được chuẩn hóa bởi phương trình. 5. Để các cạnh dọc, bộ lọc này có tính đặc hiệu là $S = \frac{10\times5^{1/4}}{9}$ $+$ $2$ $\approx$ $3.661498645$ , trái ngược với tính đặc hiệu $S = 2$ của bộ lọc phái sinh Gaussian bậc nhất đối với $x$ . Phần cuối của phương trình. 8 có khả năng chuẩn hóa tương thích với các bộ lọc phái sinh Gaussian 2-d tách rời khỏi Python scipy.ndimage.gaussian_filter:

import matplotlib.pyplot as plt
import numpy as np
import scipy.ndimage

sig = 8;
N = 161
x = np.zeros([N, N])
x[N//2, N//2] = 1
ddx = scipy.ndimage.gaussian_filter(x, sigma=[sig, sig], order=[0, 1], truncate=(N//2)/sig)
ddx3 = scipy.ndimage.gaussian_filter(x, sigma=[np.sqrt(5)*sig, np.sqrt(5)*sig], order=[0, 3], truncate=(N//2)/(np.sqrt(5)*sig))
ddxddy2 = scipy.ndimage.gaussian_filter(x, sigma=[np.sqrt(5)*sig, np.sqrt(5)*sig], order=[2, 1], truncate=(N//2)/(np.sqrt(5)*sig))

hx = 3.8275359956049814*sig**2*ddx - 33.044650082417731*sig**4*(ddx3 - 3*ddxddy2)
plt.imsave('hx.png', plt.cm.bwr(plt.Normalize(vmin=-hx.max(), vmax=hx.max())(hx)))

h = scipy.ndimage.gaussian_filter(x, sigma=[sig, sig], order=[0, 0], truncate=(N//2)/sig)
plt.imsave('h.png', plt.cm.bwr(plt.Normalize(vmin=-h.max(), vmax=h.max())(h)))
h1x = scipy.ndimage.gaussian_filter(x, sigma=[sig, sig], order=[0, 3], truncate=(N//2)/sig) - 3*scipy.ndimage.gaussian_filter(x, sigma=[sig, sig], order=[2, 1], truncate=(N//2)/sig)
plt.imsave('ddx.png', plt.cm.bwr(plt.Normalize(vmin=-ddx.max(), vmax=ddx.max())(ddx)))
plt.imsave('h1x.png', plt.cm.bwr(plt.Normalize(vmin=-h1x.max(), vmax=h1x.max())(h1x)))
plt.imsave('gaussiankey.png', plt.cm.bwr(np.repeat([(np.arange(161)/160)], 16, 0)))

Hình 4. Các sơ đồ tỷ lệ 1: 1 được ánh xạ màu theo thứ tự: Hàm Gaussian 2-d, đạo hàm của hàm Gaussian đối với $x$ , một toán tử vi phân $\big(\frac{d}{dx}\big)^3-3\frac{d}{dx}\big(\frac{d}{dy}\big)^2$ áp dụng cho hàm Gaussian, bộ lọc phát hiện cạnh dọc có nguồn gốc Gaussian hai thành phần tối ưu $h_x(x, y, \sigma)$ của phương trình 8. Độ lệch chuẩn của mỗi Gaussian là $\sigma = 8$ ngoại trừ thành phần lục giác trong ô cuối cùng có độ lệch chuẩn $\sqrt{5}\times8$ . Phím màu: xanh dương: tối thiểu, trắng: không, đỏ: tối đa.

CÒN TIẾP...

— Olli Niemitalo
nguồn