直交特徴を持つ任意画像上の回転角度の自動検出

次のサンプル（マイクロチップ写真の一部）のように、画像の角度を検出する必要があるタスクがあります。画像には直交する特徴が含まれていますが、解像度やシャープネスが異なるため、サイズが異なる場合があります。一部の光学的な歪みと収差のため、画像はわずかに不完全になります。サブピクセル角度検出精度が必要です（つまり、誤差は0.1°未満である必要があり、0.01°程度が許容されます）。参考までに、この画像の最適な角度は約32.19°です。

現在、私は2つのアプローチを試しました。どちらも、2°ステップの極小値に対してブルートフォース検索を実行してから、勾配を0.0001°ステップサイズまで下げます。

1. メリット関数はsum(pow(img(x+1)-img(x-1), 2) + pow(img(y+1)-img(y-1))画像全体で計算されます。水平/垂直線が揃っている場合-水平/垂直方向の変化が少ない。精度は約0.2°でした。
2. メリット関数は、画像の一部のストライプ幅/高さにわたって（最大-最小）です。このストライプも画像全体にループされ、メリット関数が蓄積されます。このアプローチは、水平/垂直線が整列しているときの明るさの小さな変化にも焦点を当てますが、大きなベース（ストライプ幅-約100ピクセル幅になる可能性があります）全体で小さな変化を検出できます。これにより、最高0.01°までの精度が向上しますが、微調整するパラメータが多数あります（たとえば、ストライプの幅/高さは非常に敏感です）。これは、現実の世界では信頼できない場合があります。

エッジ検出フィルターはあまり役に立ちませんでした。

私の懸念は、ワーストアングルとベストアングルの間の両方のケースでメリット関数の非常に小さな変化（<2x差）です。

角度検出のためのメリット関数の記述について、何か良い提案はありますか？

更新：フルサイズのサンプル画像はここにアップロードされます（51 MiB）

結局のところ、このようになります。

私があなたの方法1を正しく理解している場合、それを使用して、円対称の領域を使用し、領域の中心を中心に回転させた場合、回転角度に対する領域の依存性を排除し、間のメリット関数によってより公平な比較を得るでしょう。異なる回転角度。基本的にそれと同等の方法を提案しますが、画像全体を使用し、画像の回転を繰り返す必要がなく、ローパスフィルタリングを含めて、ピクセルグリッドの異方性を除去し、ノイズを除去します。

等方性ローパスフィルター処理されたイメージの勾配

最初に、フルサイズのサンプル画像の緑のカラーチャネルの各ピクセルでローカルグラデーションベクトルを計算します。

理想的なローパスフィルターの連続空間インパルス応答をフラットな円形周波数応答で微分することにより、水平および垂直微分カーネルを導出しました。これにより、対角線上で比較される詳細レベルに違いがないことを確認することにより、画像軸の選択の影響を排除します。結果の関数をサンプリングし、回転した余弦ウィンドウを適用することにより、水平または垂直に：

$$\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}$$

ここで、は第1種の2次ベッセル関数、はラジアン単位のカットオフ周波数です。Pythonソース（式1のマイナス記号はありません）：$J_2$$\omega_c$

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()

図1. 2次元回転コサインウィンドウ。

図2.ウィンドウ化された水平等方性ローパス微分カーネル、異なるカットオフ周波数 $\omega_c$設定。上：omega_c = np.pi、中央：omega_c = np.pi/4、下：omega_c = np.pi/16。式のマイナス記号。1つが除外されました。垂直カーネルは同じように見えますが、90度回転されています。重み付きの水平カーネルと垂直カーネルの重み付き合計$\cos(\phi)$ そして $\sin(\phi)$、それぞれ、勾配角度について同じタイプの分析カーネルを提供します $\phi$。

Pythonの2次元高速フーリエ変換（FFT）でわかるように、インパルス応答の微分は帯域幅に影響を与えません。

# 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()

図3. 2次元FFTの大きさ $h_x$。周波数領域では、微分はフラットな円形通過帯域の乗算として表示されます。$\omega_x$、そしてマグニチュードでは見えない90度の位相シフトによって。

緑のチャネルのたたみ込みを実行し、Pythonで目視検査のために2次元勾配ベクトルヒストグラムを収集するには：

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)))

これはまた(N - 1)//2、ヒストグラム分析の前に、長方形の画像の境界によって汚染された各エッジからのピクセルを破棄して、データをトリミングします。

$\pi$ $\frac{\pi}{2}$ $\frac{\pi}{4}$
$\frac{\pi}{8}$ $\frac{\pi}{16}$ $\frac{\pi}{32}$ $\frac{\pi}{64}$ —$0$
図4.さまざまなローパスフィルターのカットオフ周波数に対する、勾配ベクトルの2次元ヒストグラム $\omega_c$設定。順番に：第有するN=41：omega_c = np.pi、omega_c = np.pi/2、omega_c = np.pi/4（リストのPythonと同じ）、 、omega_c = np.pi/8、omega_c = np.pi/16その後：N=81：omega_c = np.pi/32、N=161：omega_c = np.pi/64。ローパスフィルタリングによるノイズ除去により、ヒストグラムの回路トレースエッジグラディエントの方向がシャープになります。

ベクトル長加重円形平均方向

複数の風ベクトルサンプルからサンプルを1回通過することで「平均的な」風向を見つけるYamartinoの方法があります。これは、循環量の平均に基づいています。これは、周期の循環量によってシフトされたコサインの合計であるコサインのシフトとして計算されます。$2\pi$。同じ方法のベクトル長で重み付けされたバージョンを使用できますが、最初に、モジュロが等しいすべての方向をまとめる必要があります$\pi/2$。これを行うには、各勾配ベクトルの角度を掛けます$[X_k,Y_k]$ 4で、複素数表現を使用して：

$$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}$$

満足 $|Z_k| = \sqrt{X_k^2 + Y_k^2}$ と後で解釈することによって $Z_k$ から $-\pi$ に $\pi$ からの角度を表す $-\pi/4$ に $\pi/4$、計算された循環平均位相を4で割ることにより、

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

どこ $\phi$ 推定される画像の向きです。

推定の質は、データをもう一度通過し、平均の重み付けされた正方形の円形距離を計算することによって評価できます。$\text{MSCD}$、複素数のフェーズ間 $Z_k$ 推定された循環平均位相 $4\phi$、 $|Z_k|$ 重量として：

$$\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}$$

によって最小化されました $\phi$式ごとに計算 3. 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)")

私のmpmath実験に基づいて（図には示されていません）、非常に大きな画像でも数値の精度が不足することはないと思います。異なるフィルター設定（注釈付き）の場合、出力は-45度から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)

強力なローパスフィルタリングは有用であると思われ、次のように計算される二乗平均平方根距離（RMSCD）の等価角度を減らします。 $\operatorname{acos}(1 - \text{MSCD})$。2次元回転コサインウィンドウがない場合、結果の一部がある程度ずれます（図には示されていません）。これは、分析フィルターの適切なウィンドウ処理を行うことが重要であることを意味します。RMSCDの等価角度は、角度推定の誤差を直接推定するものではないため、はるかに小さくする必要があります。

代替の正方形の長さの重み関数

代替の重み関数として、ベクトルの長さの2乗を試してみましょう。

$$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}$$

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)")

正方形の長さの重みにより、RMSCDの等価角度が約1度減少します。

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)

これは少し良い重み関数のようです。カットオフも追加しました$\omega_c = \pi/32$ そして $\omega_c = \pi/64$。より大きな値を使用するNと、画像のトリミングが異なり、厳密に比較可能なMSCD値は得られません。

1次元ヒストグラム

平方長の重み関数の利点は、次の1次元の重み付きヒストグラムでより明確になります。 $Z_k$フェーズ。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()

図5.ラップされた勾配ベクトル角度の線形補間された重み付きヒストグラム $-\pi/4\ldots\pi/4$重み付け（ピークで下から上へ）：重み付けなし（黒）、勾配ベクトル長（赤）、勾配ベクトル長の2乗（青）。ビンの幅は0.1度です。フィルターのカットオフはomega_c = np.pi/4、Pythonリストと同じでした。下の図はピークで拡大されています。

操縦可能なフィルター演算

このアプローチが機能することを確認しましたが、より良い数学的理解が得られると良いでしょう。の$x$ そして $y$式によって与えられる微分フィルターインパルス応答。1 は、方程式の右辺の回転からサンプリングされた、ステアリング可能な微分フィルターのインパルス応答を形成するための基底関数として理解できます。$h_x[x, y]$（方程式1）。これは、Eq。1から極座標：

$$\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}$$

ここで、水平と垂直の両方の微分フィルターインパルス応答は同じ動径因子関数を持ちます $f(r)$。ローテーションバージョン$h(r, \theta, \phi)$ の $h_x(r, \theta)$ ステアリング角度によって $\phi$ によって取得されます：

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

考えは操縦されたカーネル $h(r, \theta, \phi)$ の加重和として構築できます $h_x(r, \theta)$ そして $h_x(r, \theta)$、 $\cos(\phi)$ そして $\sin(\phi)$ 重みとして、そしてそれは確かにそうです：

$$\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}$$

等方性ローパスフィルター処理された信号を入力信号と見なし、最初の回転座標に関する偏微分演算子を作成すると、同等の結論が得られます。 $x_\phi$、 $y_\phi$ 角度で回転 $\phi$ 座標から $x$、 $y$。（導出は、線形時間不変システムと見なすことができます。）

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

偏導関数のチェーンルールを使用すると、$x_\phi$ に関する偏導関数のコサインおよびサイン加重和として表すことができます $x$ そして $y$：

$$\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}$$

まだ検討されていない問題は、勾配ベクトル角度の適切に重み付けされた円形平均がどのように角度に関係するかです $\phi$ ある意味で「最も活性化された」操縦微分フィルター。

可能な改善

結果をさらに改善するために、赤と青のカラーチャネルについても勾配を計算し、「平均」計算に追加データとして含めることができます。

私はこの方法の可能な拡張を念頭に置いています：

1）勾配を検出するのではなく、より大きな分析フィルターカーネルのセットを使用して、エッジを検出します。これは、すべての方向のエッジが等しく扱われるように注意深く作成する必要があります。つまり、任意の角度のエッジ検出器は、直交カーネルの加重和によって取得できる必要があります。式（1）の微分演算子を適用することで、適切なカーネルのセットを取得できます（私はそう思います）。円対称ローパスフィルターの連続空間インパルス応答の11、図6（私の数学スタック交換の投稿も参照）。

$$\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}$$

図6. 高次エッジ検出器を構築するための微分演算子のディラックデルタ相対位置。

2）循環量の（加重）平均の計算は、量のサンプルによってシフトされた（および加重によってスケーリングされた）同じ周波数のコサインを合計し、結果の関数のピークを見つけることとして理解できます。慎重に選択された相対振幅を使用して、シフトされた余弦の同様にシフトおよびスケーリングされた高調波が混合に追加され、よりシャープな平滑化カーネルが形成されると、合計に複数のピークが表示され、最大値のピークが報告されます。高調波の適切な混合により、分布のメインピークから離れた外れ値をほとんど無視する一種の局所平均が得られます。

代替アプローチ

画像を角度で畳み込むことも可能です $\phi$ と角度 $\phi + \pi/2$回転した「長いエッジ」カーネル、および2つの畳み込み画像のピクセルの平均二乗を計算するため。角度$\phi$平均二乗を最大化することが報告されます。このアプローチは、完全な角度を検索するのが危険であるため、画像の向きを見つけるための良い最終的な改善をもたらすかもしれません$\phi$ 大きなステップのスペース。

別のアプローチは、非局所的な方法です。たとえば、長い水平または垂直のトレース、または水平または垂直に何度も繰り返されるフィーチャがあることがわかっている場合に適用できる、遠くの類似した領域を相互相関させます。

ここにも同様のDSPトリックがありますが、詳細を正確に覚えていません。

どこかで、どこかで読んだことがあります。これは、向きに関係なく、ファブリックパターンの一致を把握することに関係しています。ですから、それについて調査したいかもしれません。

円のサンプルをつかみます。円のスポークに沿って合計して、円周プロファイルを取得します。その後、DFTを実行しました（結局のところ、それは本質的に循環です）。位相情報をトスして（向きに依存しないようにして）、比較を行います。

次に、2つのファブリックに同じパターンがあるかどうかを確認できました。

あなたの問題も同様です。

最初に試してみるまでもなく、DFT前のプロファイルの特性が方向性を明らかにするように思えます。合計の代わりにスポークに沿って標準偏差を行うと、おそらく両方ともうまくいくはずです。

これで、方向性のある参照画像があれば、それらの手法を使用できます。

セド

---

精度要件はかなり厳しいです。

私はこれを強打しました。各色のスポークに沿った2つの後続のポイント間の差の絶対値の合計を取ります。

こちらが円周周りのグラフです。値は白いマーカーでプロットされます。

あなたはそれをある程度見ることができますが、これがあなたのために働くとは思いません。ごめんなさい。

---

進捗レポート：いくつか

私は3つのステップのプロセスを決定しました。

1）評価スポットを見つけます。

2）粗い測定

3）精密測定

現在、最初のステップはユーザーの発明です。自動化できるはずですが、気になりません。2番目のステップの大まかなドラフトがあります。試してみたい微調整がいくつかあります。最後に、3番目のステップの候補がいくつかあり、どれが最も効果的かをテストするためにテストを行います。

良いニュースは、それが速く点灯していることです。あなたの唯一の目的がウェブページ上で画像の見た目レベルを作ることであるなら、あなたの許容範囲はあまりにも厳しく、粗い測定は十分に正確でなければなりません。

これは粗い測定です。各ピクセルは約0.6度です。（編集、実際には0.3）

---

進捗レポート：良い結果を得ることができます

ほとんどはこれほど良くはありませんが、安価で（そしてかなりローカル）、良い読み取りを行うスポットを見つけるのは簡単です.....人間にとっては。ブルートフォースはプログラムにとってはうまく機能するはずです。

結果は大幅に改善されます。これは単純なベースラインテストです。私はまだ説明をする準備ができていませんし、コードを投稿することもできませんが、このスクリーンショットはフォトショップではありません。

---

進捗レポート：コードが投稿されました。しばらくこれで終わりです。

このスクリーンショットは、マーカスの45度ショットに取り組んでいるプログラムです。

カラーチャンネルは個別に処理されます。

ポイントがスイープの中心として選択されます。

直径は離散的な角度で180度スイープされます

各角度で、「ボラティリティ」は直径全体で測定されます。サンプルを収集するチャネルごとにトレースが作成されます。サンプル値は、サンプルスポットが着地するグリッドスクエアの4つのコーナー値の線形補間です。

各チャネルトレース

サンプルはVonHannウィンドウ関数で乗算されます

A スムーズ/パスを異なりますサンプルに対して行われます

DifferのRMSはボラティリティメジャーとして使用されます

下の行のグラフは次のとおりです。

最初は0から180度のスイープで、各ピクセルは0.5度です。2番目は、選択した角度の周りのスイープです。各ピクセルは0.1度です。3番目は、選択した角度の周りのスイープです。各ピクセルは0.01度です。4番目はトレースの差分曲線です

最初の選択は、3つのチャネルの最小平均ボラティリティです。これは最適な角度に近くなりますが、通常はオンになりません。谷での対称性は、最小値よりも優れた指標です。その近所の最適な放物線は非常に良い答えをもたらすはずです。

ソースコード（GambasのPPA gambas-team / gambas3）は、次の場所にあります。

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

これは通常のzipファイルなので、ソースを見るためにGambasをインストールする必要はありません。ファイルは「.src」サブディレクトリにあります。

VonHannウィンドウを削除すると、トレースが効果的に長くなるため精度が高くなりますが、ぐらつきが追加されます。中心が重要ではなく、「シーソーが地面に当たったとき」のより早い開始が検出されるので、ダブルVonHannはおそらくより良いでしょう。画像が許す限りトレース長を長くすることで精度を簡単に改善できます（はい、それは自動化可能です）。より良いウィンドウ関数、sinc？

現在の設定で私が取った対策は、3.19値+/-。03 ishを確認します。

これは単なる測定ツールです。画像に適用するために考えられるいくつかの戦略があります。彼らが言うように、それは読者のための練習です。または、この場合はOP。後で自分で試してみるつもりです。

アルゴリズムとプログラムの両方に改善の余地はありますが、すでに非常に有用です。

これが線形補間の仕組みです

'----整数部分

        x =床（rx）
        y = Floor（ry）

'----分数部分

        fx = rx-x
        fy = ry-y

        gx = 1.0-fx
        gy = 1.0-fy

' -  -  加重平均

        vtl = ArgValues [x、y] * gx * gy '左上
        vtr = ArgValues [x + 1、y] * fx * gy '右上
        vbl = ArgValues [x、y + 1] * gx * fy '左下
        vbr = ArgValues [x + 1、y + 1] * fx * fy 'ボトムリグス

        v = vtl + vtr + vbl + vbr

誰かがその慣習的な名前を知っていますか？

むしろパフォーマンスを重視しますが、必要に応じて精度を上げる必要があります。

• エッジ検出画像
• 必要な精度のために十分なピクセルがあるスペースにハフ変換します。
• 十分な直交線があるため、ハフ空間の画像には、2つの線上にある最大値が含まれます。これらは簡単に検出でき、目的の角度を提供します。

私は先に進んで、基本的にopencvのハフ変換の例をあなたのユースケースに合わせました。アイデアはいいですが、エッジの効いた性質のため、画像には既に多くのエッジがあるので、エッジ検出はあまりメリットがありません。

だから、私が上記の例で言ったのは

• エッジ検出を省略
• 入力画像をカラーチャネルに分解し、個別に処理する
• 特定の角度でラインの出現をカウントします（角度を量子化し、90を法としてそれらを取得した後、十分な直角があるため）。
• カラーチャンネルのカウンターを組み合わせる
• これらの回転を修正する

推定の品質をさらに向上させるためにできること（以下に示すように、一番上の推測は正しくありませんでした。2番目は正しくありません）は、異なる画像間の実際の違いを表すグレースケール画像に画像を変換することになるでしょう。最高の素材–明らかに、RGBチャンネルは最高ではありません。あなたは半導体の専門家なので、メタライゼーションとシリコンなどの違いを最大化する方法でカラーチャネルを組み合わせる方法を見つけます。

私のジュピターノートはこちらです。以下の結果を参照してください。

角度分解能を上げるには、QUANT_STEP変数とhough_transform呼び出しの角度精度を上げます。このコードを20分未満で記述したかったため、計算に1分も投資したくなかったので、そうしませんでした。

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]))

これは、私の以前の回答の最初に提案された拡張機能への挑戦です。

理想的な円対称の帯域制限フィルター

半径の円の内側に帯域制限された4つのフィルターの直交バンクを構築します$\omega_c$周波数平面上。これらのフィルターのインパルス応答を線形に組み合わせて、方向性エッジ検出カーネルを形成できます。任意に正規化された直交フィルターインパルス応答のセットは、「ビーチボールのような」微分演算子の最初の2つのペアを、円対称の理想的な帯域制限フィルターインパルス応答の連続空間インパルス応答に適用することによって取得されます。$h(x,y)$：

$$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{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{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}$$

どこ $J_\alpha$である第一種のベッセル関数オーダーの$\alpha$ そして $\propto$「に比例する」を意味します。Wolfram Alphaクエリ（（ᵈ/ dx）³ ; ᵈ/ dx ; ᵈ/ dx（ᵈ/ dy）²）を使用して微分を実行し、結果を簡略化しました。

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)))

図1.円周対称の帯域制限フィルターインパルス応答のカラーマップ1：1スケールプロット、カットオフ周波数 $\omega_c = \pi/8$。カラーキー：青：ネガティブ、白：ゼロ、赤：最大。

図2.カットオフ周波数を使用した、フィルターバンク内のフィルターのサンプリングされたインパルス応答のカラーマップ1：1スケールプロット $\omega_c = \pi/8$、 順番に： $h_{0x}$、 $h_{0y}$、 $h_{1x}$、 $h_{0y}$。カラーキー：青：最小、白：ゼロ、赤：最大。

方向エッジ検出器は、これらの加重和として構築できます。Pythonの場合（続き）：

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()

図3.図2のカーネルの加重和として構築された方向エッジ検出カーネル。カラーキー：青：最小、白：ゼロ、赤：最大。

図3のフィルターは、勾配フィルター（図2の最初の2つのフィルター）と比較して、連続エッジに対してより適切に調整する必要があります。

ガウスフィルター

図2のフィルターは、厳密な帯域制限のために多くの振動を持っています。おそらく、ガウス微分フィルターのように、より良い開始点はガウス関数でしょう。比較的、数学的に処理する方がはるかに簡単です。代わりに試してみましょう。ガウスの「ローパス」フィルターのインパルス応答の定義から始めます。

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

式の演算子を適用します。2〜$h(x, y, \sigma)$ 各フィルターを正規化します $h_{..}$ 沿って：

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

$$\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}$$

これらを加重和として、特異性を最大化する垂直エッジ検出フィルターのインパルス応答を構築します $S$ これは、考えられるエッジシフトに対する垂直エッジに対する平均感度です。 $s$ 可能なエッジ回転角度での平均感度と比較して $\beta$ そして可能なエッジシフト $s$：

$$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}$$

加重和のみが必要です $h_{0x}$ 変動あり $\sigma^2$ そして $h_{1x}$最適な分散で。それが判明$S$ インパルス応答によって最大化されます：

$$\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}$$

式によっても正規化されます。5.垂直エッジに対して、このフィルターには次の特性があります。$S = \frac{10\times5^{1/4}}{9}$ $+$ $2$ $\approx$ $3.661498645$、特異性とは対照的に $S = 2$ に関する一次ガウス微分フィルターの $x$。式の最後の部分。8は、Pythonの分離可能な2次元ガウス微分フィルターと互換性のある正規化を備えています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)))

図4.カラーマップされた1：1スケールプロットの次の順序：2次元ガウス関数。 $x$、微分演算子 $\big(\frac{d}{dx}\big)^3-3\frac{d}{dx}\big(\frac{d}{dy}\big)^2$ ガウス関数に適用される、最適な2コンポーネントガウス派生垂直エッジ検出フィルター $h_x(x, y, \sigma)$式の 8.各ガウスの標準偏差は$\sigma = 8$ 最後のプロットの標準偏差を持つ六角形のコンポーネントを除いて $\sqrt{5}\times8$。カラーキー：青：最小、白：ゼロ、赤：最大。

つづく...