【古典的な画像ワーピング手法】Thin Plate Spline：TPSの理論とコードを詳しく解説

0. 序文

2022年は新しいブログは書かず、論文執筆を中心に活動していきますので、今年から本格的に回復していきます！

この記事の目的は、ランドマーク (記事の後半ではコントロール ポイントと呼ばれることもあります) に基づいた古典的な画像ワーピング (歪み/変形) アルゴリズムである Thin Plate Spine (TPS) を詳細に分析することです。

TPS はさまざまなタスク、特に人間の顔、動物の顔などの生物学的形状で広く使用されています TPS は 3 次スプラインの 2D 一般化形式です 画像処理で一般的に使用されることは注目に値します アフィン変換は特別なバリアントとして理解できますTPSの。

• 画像の歪み/変形の問題とは何ですか? 2 つの画像に[3]
  対応する制御点 (図の緑色の接続線で示されているランドマーク) がいくつかあるとすると、画像 A (参照画像)に特定の変形を実行して、その制御点が次のようになります。比較画像B（対象テンプレート）のランドマークが重なっています。

TPS は最も古典的な手法の 1 つであり、その基本的な前提条件は次のとおりです。
如果用一个薄钢板的形变来模拟这种2D形变, 在确保landmarks能够尽可能匹配的情况下，怎么样才能使得钢板的弯曲量(deflection)最小。

• 使用例
  TPS アルゴリズムの私の実践での使用方法は、画像のランドマーク(下図の左側の黒い三角形) に従って、マッピング関係(緑色の接続線)に従って2D 画像を論理的にワーピング (ワーピング) します。ターゲット テンプレート(下図の右側) )にコピーします。
  

1. 理論

Thin-Plate-Spline、この記事の残りの部分はその略語TPSに置き換えられます。TPS は実際には数学的な概念です[1]。

TPS は 1D 3 次スプラインの 2 次元シミュレーションであり、二調和方程式(Biharmonic Equation)の基本解であり[2]、その形式は次のとおりです。

$$U\left(r\right)=r^2\ln \left(r\right)$$

1.1 $U\left(r\right)$の形の起源

では、なぜこのような形になっているのでしょうか? [10]1989 年に Bookstein によって出版された論文「Principle Warps: Thin-Plate Splines and the Decomposition of Deformation」では、彼はそれを二調和方程式の基本解法で拡張しました。

まず、$r$はx 2 + y 2 \sqrt{x^2+y^2}を表します$\sqrt{{バツ}^2+y^2}$(デカルト座標系)、論文ではブックスタインは$U\left(r\right)=-r^2\ln \left(r\right)$ 、その目的は視覚化の便宜のためこのポーズでは、上から見るとわずかにへこんでいるように見えますが、それ以外の場合は凸面になります(つまり、中心 X 点付近の領域がへこんでいるように見えます)。).

この関数は当然次の方程式を満たします。

$$D^{2U}\_=(\frac{{\partial }^{}}{\partial {\times }^2}+\frac{{\partial }^{}}{\partial y{\_}^2}{)}^{2U}\_\propto d_{(0,0}$$

式の左辺と$d_{(0,0}$同等 (関数の導入は次のとおり)、$d_{(0,0}$これは (0,0) を除く他の位置では 0 になる関数であり、その積分は 1 になります (ディラック デルタ関数はこの関数の形式として理解されるべきだと思います)。

したがって、二調和方程式の形式はΔ 2 U = 0 \Delta^2U=0であるため、$D^{2U}\_=0$の場合、明らかに、$U\left(r\right)=(\pm )r^2\ln \left(r\right)$はすべてこの条件を満たすため、二調和関数の基本解。

簡単に言うと、関数は、定義域が関数のセットであり、その値の範囲が実数または複素数であるマッピングです。関数の例はZhihuから借用しています: 2D 平面上の 2 点間の直線距離図に示すように、2次元平面空間において、座標原点(0,0)から点(a,b)までの接続曲線は、y = y ( x ) y = y(x)となります。[11]

$y=y\left(x\right)$、および接続曲線の微小要素$\Delta または$ds = 1 + ($ds\_=\sqrt{1+(\frac{やあ}{dx\_}{)}^{2dx}\_\_}$、全長は$ds$在$[0,a]$の積分
$$s={\int }_0^{}(1+y^{{}^{\text{'}}2}{)}^{1/2}dx$$ここ、$s$はスカラー、$y^{{}^{\text{'}}}\left(x\right)$汎関数でありs ( y ' ) s(y^{'})とも書かれます。$s\left({と}^{{}^{\text{'}}}\right)$. すると、上記の問題は次のようになります: 曲線$y\left(x\right)$は関数$s\left({と}^{{}^{\text{'}}}\right)$最小限。

わかりました、$U$の起源と定義が明確になったので、私たちの目標は次のとおりです。

サンプル ポイントのセットが与えられると、各サンプル ポイントを中心とする薄板スプライン (TPS) の重み付けされた組み合わせにより、いわゆる曲げエネルギーを最小限に抑えながら、これらのポイントを正確に通過する内挿関数が得られます 。

では、曲げエネルギーとは何でしょうか?

1.2 曲げエネルギー: 曲げエネルギー

によれば、ここでの曲げエネルギーは、実数体R 2 R^2[1]に関する二次導関数の 2 乗として定義されます。$R^2$ (私の意見では、ここでは$R^{2\; は、}$ 2D 画像の高さと幅の積分として直接理解できます。

$$I\left[f\right(x,y)]=\iint (f_{xx}^{}+2f{\_}_{ｘｙ}^{}+f_{やあ}^{})dxdy$$

最適化の目標は、$I\left[f\right(x,y)]$を最小化します。

さて、曲げエネルギーの数学的定義はこれで終わりですが、当然、次のような疑問が生じます。

• $f(x,y)$はどのように定義されますか?
• 画像のような 2D 平面の場合、曲げエネルギーを最小限に抑えるためにスプラインの重み付けを組み合わせた後の曲げ方向はどうあるべきですか?

まず、曲げの方向の問題を解析して、1.4でf (x, y) f(x, y)を実行してみます。$f(x,y)$定義の紹介。

1.3 曲げ方向

まず、TPS の名前をおさらいしてみましょう。TPS は、薄い金属シートを曲げることという物理的なアナロジーに由来しています。

物理用語では、曲げ（たわみ）の方向は$z$軸は 2D 画像平面に垂直な軸であり、
この考え方を実際の座標変換の問題に適用するには、TPS を平板を上げ下げし、その上げ下げした平面を 2D に投影すると画像平面は、参照画像と対象テンプレートのランドマーク対応関係に基づいてワーピング（変形）した後の画像結果です。

以下のように、プレーン上に 4 つのコントロール ポイントを設定し、最後の 1 つはエッジ コーナー ポイントではないので、引っ張ると、プレーンは自然に部分的に盛り上がったり下がったりする効果が得られます。

明らかに、この種のワープは、下図に示すように、参照ランドマークの赤いXXを考慮すると、ある程度の座標変換でもあります。$X$とターゲット ポイントの青色$⚪$ . TPS ワーピングはこれらの$X\; は$⚪ ⚪に完全に移動します$⚪上$。

ここで質問が来ます。次に、この$バツ\to ⚪$モバイル ソリューションはどのように実装されますか?

1.4 2D 平面の座標変換 (別名ワーピング) を実装するにはどうすればよいですか?

以下に示すように[7]、2D 平面上の座標変換は実際には 2 方向の変化です: $X$和$Y$方向これら 2 つの方向の変化を実現するための TPS のアプローチは次のとおりです。

2 つのスプライン関数を使用してそれぞれ$X$和$Y$方向の変位。

TPS actually use two splines, 
one for the displacement in the X direction 
and one for the displacement in the Y direction

これら 2 つのスプライン関数の定義は次のとおりです[7]( $N\; は$、上の図に示すように、対応するランドマークの数を指します。N$N=5$ ):

各方向 ( $\times 、Y$ )Function($\Delta X、\Delta Y$ ) はNNとして見ることができます$N$点の高さマップ (高さマップ)なので、スプラインは下図に示すように点を[7]。

スプライン関数の定義式では、

• 前3个系数${ある}_{}、{ある}_{}、{ある}_{}$線形空間の一部（線部分）を表し、 XXを線形空間に当てはめるために使用します$X$ (${バツ}_{}、y_{}$) と$⚪$ (${バツ}_{私}^{{}^{}}、y_{私}^{{}^{}}$）。
• 次の係数$w_{}、私\in [1、N]\; は$各制御点を表します$i$のカーネル重み。制御点$X$ (${バツ}_{}、y_{}$) とその最後の$\times 、y$間の変位。
• 最后的一项是$U(||(x_{}、y_{})-(x,y)||)$、これは制御点$X$ (${バツ}_{}、y_{}$) とその最後の$\times 、y$間の変位。U ( ∣ ∣ ( xi , yi ) − ( x , y ) ∣ ∣ ) U(|| (x_i, y_i) - (x, y) ||) であることに注意してください。$U(||(x_{}、y_{})-(x,y)||)\; は$L2ノルムを使用します[8]。$U$定义如下: $$U\left(r\right)=r^2\ln \left(r\right)$$ここで、TPS の RBF 関数 (動径基底関数)を再検討する必要があります: U ( r ) = r 2 ln ⁡ ( r ) U(r) = r^2 \ln(r)$U\left(r\right)=r^2\ln \left(r\right)$上記によれば[9]、RBFのようなガウシアンカーネルは類似性を測定する方法（類似性測定）。

1.5 具体的な計算計画

各方向について ( $\times 、Y$のスプライン関数の${ある}_{}、{ある}_{}、{ある}_{}、w_{}$は、次の線形システムを解くことによって取得できます。

ここで、$K_{}=U(||(x_{}、y_{})-({\times }_{}、y_{})||)$、$ピーズ$Ⅱ_$行i$は同次表現$(1、{バツ}_{}、y_{})$、$O$はすべて 0 の 3x3 行列です$o$は 3x1 のすべてゼロの列ベクトルです、$w$和$v$是$w_{}$和$v_{}$.aaで構成される列ベクトル$a$是由$[{\_}_{}、{ある}_{}、{ある}_{}]$列ベクトルで構成されます。

具体的には、左側の大きな行列の形式は次のようになります[9-10]。

N=3 (制御点の数は 3) を例にとると、X \mathbf{X}注:$[\; U\; 11\; U\; 21\; U\; 31\; 1\; x\; 1\; y\; 1\; U\; 12\; U$
$$\left[\begin{array}{cccccc}{U}_{}& U_{}& U_{}& 1& {バツ}_{}& y_{}\\ U_{}& U_{}& U_{}& 1& {バツ}_{}& y_{}\\ U_{}& U_{}& U_{}& 1& {バツ}_{}& y_{}\\ 1& 1& 1& 0& 0& 0\\ {バツ}_{}& {バツ}_{}& {バツ}_{}& 0& 0& 0\\ y_{}& y_{}& y_{}& & & \end{array}\right]\times \left[\begin{array}{c}{w}_{}\\ w_{}\\ w_{}\\ {ある}_{}\\ {ある}_{}\\ {ある}_{}\end{array}\right]=\left[\begin{array}{c}{バツ}_1^{{}^{}}\\ {バツ}_2^{{}^{}}\\ {バツ}_3^{{}^{}}\\ 0\\ 0\\ \end{array}\right]$$

同様に、$Y$のスプライン関数の線形行列式は次

$$\left[\begin{array}{cccccc}{U}_{}& U_{}& U_{}& 1& {バツ}_{}& y_{}\\ U_{}& U_{}& U_{}& 1& {バツ}_{}& y_{}\\ U_{}& U_{}& U_{}& 1& {バツ}_{}& y_{}\\ 1& 1& 1& 0& 0& 0\\ {バツ}_{}& {バツ}_{}& {バツ}_{}& 0& 0& 0\\ y_{}& y_{}& y_{}& & & \end{array}\right]\times \left[\begin{array}{c}{w}_{}\\ w_{}\\ w_{}\\ {ある}_{}\\ {ある}_{}\\ {ある}_{}\end{array}\right]=\left[\begin{array}{c}{y}_1^{{}^{}}\\ y_2^{{}^{}}\\ y_3^{{}^{}}\\ 0\\ 0\\ \end{array}\right]$$

N+3 個の未知量を解くために N+3 個の関数が使用されることは明らかであり、対応する$\left[\begin{array}{c}w\\ \end{array}\right]$。

2. コードの実装

私が使用する TPS は cheind/py-thin-plate-spline プロジェクトです[6]。式と実装の対応を理解するために、ここでコードを詳細に分解します。

2.1 コアコンピューティングロジック

コアロジックは関数warp_image_cv:およびにありtps.tps_theta_from_points、最も基本的なサンプル コードは次のとおりです。tps.tps_gridtps.tps_grid_to_remap

def show_warped(img, warped, c_src, c_dst):
    fig, axs = plt.subplots(1, 2, figsize=(16,8))
    axs[0].axis('off')
    axs[1].axis('off')
    axs[0].imshow(img[...,::-1], origin='upper')
    axs[0].scatter(c_src[:, 0]*img.shape[1], c_src[:, 1]*img.shape[0], marker='^', color='black')
    axs[1].imshow(warped[...,::-1], origin='upper')
    axs[1].scatter(c_dst[:, 0]*warped.shape[1], c_dst[:, 1]*warped.shape[0], marker='^', color='black')
    plt.show()

def warp_image_cv(img, c_src, c_dst, dshape=None):
    dshape = dshape or img.shape
    theta = tps.tps_theta_from_points(c_src, c_dst, reduced=True)
    grid = tps.tps_grid(theta, c_dst, dshape)
    mapx, mapy = tps.tps_grid_to_remap(grid, img.shape)
    return cv2.remap(img, mapx, mapy, cv2.INTER_CUBIC)

img = cv2.imread('test.jpg')

c_src = np.array([
    [0.44, 0.18],
    [0.55, 0.18],
    [0.33, 0.23],
    [0.66, 0.23],
    [0.32, 0.79],
    [0.67, 0.80],
])

c_dst = np.array([
    [0.693, 0.466],
    [0.808, 0.466],
    [0.572, 0.524],
    [0.923, 0.524],
    [0.545, 0.965],
    [0.954, 0.966],
])


warped_front = warp_image_cv(img, c_src, c_dst, dshape=(512, 512))
show_warped(img, warped1, c_src_front, c_dst_front)

このオープン ソース コードには numpy と torch の 2 つのバージョンがあります。ここでは、GPU を持たない友人がハンズオン テストを実行できるように、私の分析は numpy バ​​ージョンで実行されます。

コアTPS

class TPS:       
  @staticmethod
   def fit(c, lambd=0., reduced=False):        
      n = c.shape[0]

      U = TPS.u(TPS.d(c, c))
      K = U + np.eye(n, dtype=np.float32)*lambd

      P = np.ones((n, 3), dtype=np.float32)
      P[:, 1:] = c[:, :2]
      v = np.zeros(n+3, dtype=np.float32)
      v[:n] = c[:, -1]

       A = np.zeros((n+3, n+3), dtype=np.float32)
       A[:n, :n] = K
       A[:n, -3:] = P
       A[-3:, :n] = P.T
       theta = np.linalg.solve(A, v) # p has structure w,a
       return theta[1:] if reduced else thete      
       ...
   @staticmethod
   def z(x, c, theta):
       x = np.atleast_2d(x)
       U = TPS.u(TPS.d(x, c))
       w, a = theta[:-3], theta[-3:]
       reduced = theta.shape[0] == c.shape[0] + 2
       if reduced:
           w = np.concatenate((-np.sum(w, keepdims=True), w))
       b = np.dot(U, w)
       return a[0] + a[1]*x[:, 0] + a[2]*x[:, 1] + b

2.2tps.tps_theta_from_points

この関数の機能は、スプライン関数の$\left[\begin{array}{c}w\\ \end{array}\right]$。

def tps_theta_from_points(c_src, c_dst, reduced=False):
    delta = c_src - c_dst
    
    cx = np.column_stack((c_dst, delta[:, 0]))
    cy = np.column_stack((c_dst, delta[:, 1]))
        
    theta_dx = TPS.fit(cx, reduced=reduced)
    theta_dy = TPS.fit(cy, reduced=reduced)

    return np.stack((theta_dx, theta_dy), -1)

1. デルタは、参照画像の制御点とターゲット テンプレートの制御点の間の補間$\Delta x\_{\_}_{}、\Delta y\_{\_}_{}$

2. cxとcyは に基づいており、c_dstそれぞれ$\Delta x\_{\_}_{}$和$\Delta y\_{\_}_{}$の列ベクトル

3. theta_dxとtheta_dyの Reduce パラメーターはデフォルトで False/True に設定され、結果は長さ 9/8 の1D ベクトルになります。計算プロセスにはfitTPS コア クラスの機能が必要です。

①TPS.d(cx, cx, reduced=True)またはTPS.d(cy, cy, reduced=True) L2を計算する

    @staticmethod
    def d(a, b):
        # a[:, None, :2] 是把a变成[N, 1, 2]的tensor/ndarray
        # a[None, :, :2] 是把a变成[1, N, 2]的tensor/ndarray
        return np.sqrt(np.square(a[:, None, :2] - b[None, :, :2]).sum(-1))

その機能は、$||(x_{}、y_{})-(x,y)||$ (L2)、結果は形状が$ん、Nさん$の中間結果です。

② TPS.u(...) 计算$う(...)$

式とまったく同じです: $U\left(r\right)=r^2\ln \left(r\right)$ 、 rr を防ぐため$r$が小さすぎるため、イプシロン係数が追加されます$1e{\_}^{-6.}$このステップでは、$K$、形状は$ん、N$、①と同じ。

def u(r):
        return r**2 * np.log(r + 1e-6)

③ と によればcx、cy単純なスプライシングで生成できますP。

	P = np.ones((n, 3), dtype=np.float32)
	P[:, 1:] = c[:, :2] # c就是cx or cy.

④ 根据$\Delta x\_{\_}_{}$(同じ方法でcxベクトルの最後の列を取得します)、 vvを取得しますcy$v$

    # c = cx or cy
    v = np.zeros(n+3, dtype=np.float32)
    v[:n] = c[:, -1]

⑤アセンブリ行列A、つまり[10]論文中の$L$マトリックス。

     A = np.zeros((n+3, n+3), dtype=np.float32)
     A[:n, :n] = K
     A[:n, -3:] = P
     A[-3:, :n] = P.T

⑥今$L$和$Y$は既知です、$Y=\left[\begin{array}{c}v\\ \end{array}\right]$, 那么$WWAa$ 1 、 ax 、 ay a_1、 a_x、a_y${ある}_{}、{ある}_{}、{ある}_{}$のベクトルは直接線形的に解くことができます

$\left[\begin{array}{c}w\\ \end{array}\right]$ =$L^{-1}$$Y$

class TPS:       
    @staticmethod
    def fit(c, lambd=0., reduced=False):
        # 1. TPS.d
        U = TPS.u(TPS.d(c, c))
        K = U + np.eye(n, dtype=np.float32)*lambd

        P = np.ones((n, 3), dtype=np.float32)
        P[:, 1:] = c[:, :2]

        v = np.zeros(n+3, dtype=np.float32)
        v[:n] = c[:, -1]

        A = np.zeros((n+3, n+3), dtype=np.float32)
        A[:n, :n] = K
        A[:n, -3:] = P
        A[-3:, :n] = P.T

        theta = np.linalg.solve(A, v) # p has structure w,a
        return theta[1:] if reduced else theta
        
    @staticmethod
    def d(a, b):
        return np.sqrt(np.square(a[:, None, :2] - b[None, :, :2]).sum(-1))

    @staticmethod
    def u(r):
        return r**2 * np.log(r + 1e-6)

thetaつまり、関数は$\left[\begin{array}{c}w\\ \end{array}\right]$ . これは両方向 (X, Y) で必要なthetaので、

theta = tps.tps_theta_from_points(c_src, c_dst)

返されるシータは$(N+3、2）$形。

2.3tps.tps_grid

この関数は、x 方向と y 方向のイメージ プレーンのオフセットを解決します。

def warp_image_cv(img, c_src, c_dst, dshape=None):
    dshape = dshape or img.shape
    # 2.2
    theta = tps.tps_theta_from_points(c_src, c_dst, reduced=True)
    # 2.3
    grid = tps.tps_grid(theta, c_dst, dshape)
    # 2.4
    mapx, mapy = tps.tps_grid_to_remap(grid, img.shape)
    return cv2.remap(img, mapx, mapy, cv2.INTER_CUBIC)

thetaコア コード部分から、 が見つかった場合、つまり[ wa ] \begin{bmatrix}w \\ a \end{bmatrix} であることがわかります。$\left[\begin{array}{c}w\\ \end{array}\right]$tps_grid .以下の関数を使用して、

機能は次のとおりです。

def tps_grid(theta, c_dst, dshape):
    # 1) uniform_grid(...)    
    ugrid = uniform_grid(dshape)

    reduced = c_dst.shape[0] + 2 == theta.shape[0]
    # 2) 求dx和dy.
    dx = TPS.z(ugrid.reshape((-1, 2)), c_dst, theta[:, 0]).reshape(dshape[:2])
    dy = TPS.z(ugrid.reshape((-1, 2)), c_dst, theta[:, 1]).reshape(dshape[:2])
    dgrid = np.stack((dx, dy), -1)

    grid = dgrid + ugrid
    
    return grid # H'xW'x2 grid[i,j] in range [0..1]

入力は 3 つのパラメーターです。

• シータ reduced=True(N+2, 2) またはreduced=False(N+3, 2)
• c_dst (N, 2) は、ターゲット テンプレート上のコントロール ポイントまたはランドマークです。

 c_dst = np.array([
    [0.693, 0.466],
    [0.808, 0.466],
    [0.572, 0.524],
    [0.923, 0.524],
    [0.545, 0.965],
    [0.954, 0.966],
])

• dshape (H, W, 3) は、指定された参照イメージの解像度です。

出力は 1 です。

• グリッド(H、W、2)。
  その視覚化を参照してください2.3.1。

2.3.1uniform_grid

tps.tps_grid関数の最初のステップはugrid = unique_grid(dshape)です。この関数の定義は次のとおりです。その機能は 1 $(H、わ、2)$グリッド内の値はすべて 0 から 1 までの線形補間ですnp.linspace(0, 1, W(H))。

def uniform_grid(shape):
    '''Uniform grid coordinates.
    '''

    H,W = shape[:2]    
    c = np.empty((H, W, 2))
    c[..., 0] = np.linspace(0, 1, W, dtype=np.float32)
    c[..., 1] = np.expand_dims(np.linspace(0, 1, H, dtype=np.float32), -1)

    return c

返される値は(H, W, 2) (H, W, 2)ugridです。$(H、わ、2)$グリッド、その X および Y 方向の値のサイズは、下図に示すように、方向に応じて線形に拡張されます。

X方向Y

方向

2.3.2和をTPS.z求めるために解くdxdy

 # 2) 求dx和dy.
 dx = TPS.z(ugrid.reshape((-1, 2)), c_dst, theta[:, 0]).reshape(dshape[:2]) # [H, W]
 dy = TPS.z(ugrid.reshape((-1, 2)), c_dst, theta[:, 1]).reshape(dshape[:2]) # [H, W]
 dgrid = np.stack((dx, dy), -1)  # [H, W, 2]

 grid = dgrid + ugrid

次の定義から、この関数がTPS.zX 方向と Y 方向を解決するスプライン関数であることが簡単にわかります。

$$f_{(x/y{)}^{{}^{}}}(x,y）={ある}_{}+{ある}_{}バツ+{ある}_{}y+\sum _{i=1}{w}_{}U(||(x_{}、y_{})-(x,y)||)$$

混乱を招く可能性があるのは、( )のときにパラメーターが同じである理由です。x は形状ですが、それでも です2.2TPS.d()cx(cy)(H*W), 2cc_dst (N,2)。私の理解では、2.3このステップの目標は真に画像面を位置に従って移動させることであるためです。制御点（曲げエネルギーを最小にする）を求めるため、ugrid平面上でサンプリングした点に対して一律にオフセット計算（dx和）を行うことでdy、導出条件を満たすオフセットの解析解を得ることができますdgrid。

class TPS:
    ...
    @staticmethod
    def z(x, c, theta):
        x = np.atleast_2d(x)
        U = TPS.u(TPS.d(x, c)) # [H*W, N] 本例中H=W=800, N=6
        w, a = theta[:-3], theta[-3:]
        reduced = theta.shape[0] == c.shape[0] + 2
        if reduced:
            w = np.concatenate((-np.sum(w, keepdims=True), w))
        b = np.dot(U, w)
        return a[0] + a[1]*x[:, 0] + a[2]*x[:, 1] + b

ugrid+の場合、dgrid画像面全体のスプライン関数に従って計算された$dx、dy$ (オフセット) が均一の結果に追加されますX、 Y \mathbf{X}, \mathbf{Y}とugrid比較されていることがはっきりとわかります。2.3.1ugrid$\times 、Y$方向にも対応する変化が生じます

X方向Y


方向

この時点で、このステップで返されるのは実際にはX、Y \mathbf{X}, \mathbf{Y}2.3の間の値です。$\times 、対応してY$方向にねじれたグリッド (格子) $(H、わ、2)$、視覚化の結果は上記のとおりで、値の範囲は-1 から 1。

2.4tps.tps_grid_to_remap

このステップは非常に簡単です。2.3計算された **グリッド**上で$\times 、Y$方向に対応する$W$と$H.$次に、cv2.remap画像の歪み操作を実行する関数を送信します。

def warp_image_cv(img, c_src, c_dst, dshape=None):
    dshape = dshape or img.shape
    # 2.2
    theta = tps.tps_theta_from_points(c_src, c_dst, reduced=True)
    # 2.3
    grid = tps.tps_grid(theta, c_dst, dshape)
    # 2.4
    mapx, mapy = tps.tps_grid_to_remap(grid, img.shape)
    return cv2.remap(img, mapx, mapy, cv2.INTER_CUBIC)

2.4.1tps_grid_to_remapグリッドの幅と高さを単純に乗算する

def tps_grid_to_remap(grid, sshape):
    '''Convert a dense grid to OpenCV's remap compatible maps.
    Returns
    -------
    mapx : HxW array
    mapy : HxW array
    '''
    mx = (grid[:, :, 0] * sshape[1]).astype(np.float32)
    my = (grid[:, :, 1] * sshape[0]).astype(np.float32)

    return mx, my

2.4.2cv2.remap(img, mapx, mapy, cv2.INTER_CUBIC)ワープ後の結果を取得します。

cv2.remapユーザーが独自のマッピング関係を定義できる機能です。アフィン変換や変換行列による透視変換とは異なり、より柔軟なTPSマッピングです。具体例を参照してください[12]。

なお、この結果が「まえがき」の結果と異なるのは、「まえがき」ではマスキングにマスクを使用したためです。

要約する

この時点で、TPS分析は終了します。このアルゴリズムは、顔の痩身やテクスチャ マッピングなどのタスクで最も一般的です。また、非常に柔軟なワーピング アルゴリズムでもあります。今でも広く使用されています。この記事に関しては、お気軽にコメントしてください。下記にご指摘ください、
ありがとうございます^ . ^

参考文献

1. 薄板スプライン: MathWorld
2. 二調和方程式: MathWorld
3. c0ldHEart: 薄板スプライン TPS 薄板スプライン変換の基本的な理解
4. WITH: ワープモーフ
5. 薄板スプラインマッピングと主反りの近似法
6. cheind/py-薄板スプライン
7. 薄板-スプライン-反り
8. Wikipedia: 薄板スプライン
9. Deep Shallownet: 放射基底関数カーネル - ガウス カーネル
10. ブックスタイン: 反りの原理: 薄板スプラインと変形の分解
11. Zhihu: 「機能的」とは正確にはどういう意味ですか?
12. [opencv] 5.5 幾何学的変換 -- 再マッピング cv2.remap()