人脸对齐中的相似性变换

人脸对齐是大多数人脸分析算法中的一个关键模块，在人脸识别、表情识别、人脸建模等领域有着广泛的应用。人脸对齐获取图像中人脸的几何结构，基于平移、缩放和旋转得到对齐后的标准人脸。

在欧式几何中，如果两个物体具有相同的形状，或者其中一个物体的形状与另一个物体的镜像相同，那么这两个物体是相似的。更准确地说，可以通过均匀缩放（放大或缩小）并叠加必要的平移、旋转和反射来获得另一个。这意味着任意物体都可以重新缩放、重新定位和反射，以便与另一物体精确重合。如果两个物体相似，则每个物体都与另一个物体的特定均匀缩放结果一致。

目前大多数人脸对齐方案在定位关键点后采用 Umeyama 对齐算法进行处理。例如 insightface 中的 similarTransform，dlib 中的 get_face_chip_details。相似性变换由平移变换、旋转变换以及尺度变换组合而成。下面以 skimage.transform.SimilarityTransform 为例进行介绍。

SimilarityTransform

2D 相似性变换。具有以下形式：

        X = a0 * x - b0 * y + a1 =
          = s * x * cos(rotation) - s * y * sin(rotation) + a1
        Y = b0 * x + a0 * y + b1 =
          = s * x * sin(rotation) + s * y * cos(rotation) + b1

其中s是比例因子，齐次变换矩阵为:
$$\left[\begin{array}{ccc}{a}_0& b_0& a_1\\ b_0& a_0& b_1\\ 0& 0& 1\end{array}\right]$$
除了旋转和平移参数外，相似性变换还使用单个缩放因子扩展了欧几里德变换。
参数：

• matrix：（3，3）数组，可选。齐次变换矩阵。
• scale：float，可选。比例因子。
• rotation：float，可选。逆时针旋转角度（以弧度表示）。
• translation：(tx, ty)作为数组、列表或元组，可选。x，y 方向平移参数。

属性：

• params：（3，3）数组，齐次变换矩阵。

$$\left[\begin{array}{ccc}s\cos (\theta )& \sin (\theta )& t_x\\ \sin (\theta )& s\cos (\theta )& t_y\\ 0& 0& 1\end{array}\right]$$

    def __init__(self, matrix=None, scale=None, rotation=None,
                 translation=None):
        params = any(param is not None
                     for param in (scale, rotation, translation))

        if params and matrix is not None:
            raise ValueError("You cannot specify the transformation matrix and"
                             " the implicit parameters at the same time.")
        elif matrix is not None:
            if matrix.shape != (3, 3):
                raise ValueError("Invalid shape of transformation matrix.")
            self.params = matrix
        elif params:
            if scale is None:
                scale = 1
            if rotation is None:
                rotation = 0
            if translation is None:
                translation = (0, 0)

            self.params = np.array([
                [math.cos(rotation), - math.sin(rotation), 0],
                [math.sin(rotation),   math.cos(rotation), 0],
                [                 0,                    0, 1]
            ])
            self.params[0:2, 0:2] *= scale
            self.params[0:2, 2] = translation
        else:
            # default to an identity transform
            self.params = np.eye(3)

estimate

从一组对应点估计变换。可以使用总体最小二乘法确定过定、确定和欠定的参数。源坐标和目标坐标的数量必须匹配。
参数：

• src：（N，2）数组,源坐标。
• dst：（N，2）数组，目标坐标。

返回值：

• success：布尔型，如果模型估计成功，则返回True。

        self.params = _umeyama(src, dst, True)

        return True

scale

    @property
    def scale(self):
        if abs(math.cos(self.rotation)) < np.spacing(1):
            # sin(self.rotation) == 1
            scale = self.params[1, 0]
        else:
            scale = self.params[0, 0] / math.cos(self.rotation)
        return scale

_umeyama

估算是否具有缩放比例的N-D相似度变换。
估计有或无标度的N-D相似变换。
参数：

• src：（M，N）数组，源坐标。
• dst：（M，N）数组，目标坐标。
• estimate_scale：布尔，是否估计比例因子。

返回值：

• T：（N + 1，N + 1），齐次相似性变化矩阵。仅当问题条件不完善时，矩阵才会包含NaN值。

参考文献

• [1] “Least-squares estimation of transformation parameters between two point patterns”, Shinji Umeyama, PAMI 1991, :DOI:10.1109/34.88573

$$\begin{array}{rl}{\mu }_x& =\frac{1}{n}\sum _{i=1}^n{x}_i\text{(34)}\\ {\mu }_y& =\frac{1}{n}\sum _{i=1}^n{y}_i\text{(35)}\\ {\sigma }_x^2& =\frac{1}{n}\sum _{i=1}^n\Vert x_i-{\mu }_x{\Vert }^2\text{(36)}\\ {\sigma }_y^2& =\frac{1}{n}\sum _{i=1}^n\Vert y_i-{\mu }_y{\Vert }^2\text{(37)}\\ {\Sigma }_{xy}& =\frac{1}{n}\sum _{i=1}^n(y_i-{\mu }_y)(x_i-{\mu }_x{)}^{\top }\text{(38)}\end{array}$$
${\Sigma }_{xy}$ 是 $X$ 和 $Y$ 的协方差矩阵，${\mu }_x$ 和 ${\mu }_y$ 分别是 $X$ 和 $Y$ 的均值向量，${\sigma }_x^2$ 和 ${\sigma }_y^2$ 是 $X$ 和 $Y$ 的方差。
num是点的数量，dim为点的坐标维度。

    num = src.shape[0]
    dim = src.shape[1]

    # Compute mean of src and dst.
    src_mean = src.mean(axis=0)
    dst_mean = dst.mean(axis=0)

    # Subtract mean from src and dst.
    src_demean = src - src_mean
    dst_demean = dst - dst_mean

    # Eq. (38).
    A = dst_demean.T @ src_demean / num

对协方差矩阵 ${\Sigma }_{xy}$ 进行奇异值分解 $UD{V}^{\top }$，其中 $D=\mathrm{d}\mathrm{i}\mathrm{a}\mathrm{g}(d_i),d_1\ge d_2\ge \cdots \ge d_m\ge 0$。

$$S=\{\begin{array}{ll}I& \text{if }\mathrm{d}\mathrm{e}\mathrm{t}({\Sigma }_{xy})\ge 0\\ \mathrm{d}\mathrm{i}\mathrm{a}\mathrm{g}(1,1,\dots ,1,-1)& \text{if }\mathrm{d}\mathrm{e}\mathrm{t}({\Sigma }_{xy})<0\end{array}\text{(39)}$$
numpy.linalg.det 计算数组的行列式（determinant）。
numpy.linalg.svd 对数组进行奇异值分解。
S对应分解的奇异值 $\mathrm{d}\mathrm{i}\mathrm{a}\mathrm{g}(d_i)$。
d为行向量，对应公式中的 $S$。

    # Eq. (39).
    d = np.ones((dim,), dtype=np.double)
    if np.linalg.det(A) < 0:
        d[dim - 1] = -1

    T = np.eye(dim + 1, dtype=np.double)

    U, S, V = np.linalg.svd(A)

numpy.linalg.matrix_rank 使用 SVD 方法返回数组的矩阵秩。
当 $\text{rank}({\Sigma }_{xy})=m$ 时，
$$S=\{\begin{array}{ll}I& \text{if }\mathrm{d}\mathrm{e}\mathrm{t}(U)\mathrm{d}\mathrm{e}\mathrm{t}(V)=1\\ \mathrm{d}\mathrm{i}\mathrm{a}\mathrm{g}(1,1,\dots ,1,-1)& \text{if }\mathrm{d}\mathrm{e}\mathrm{t}(U)\mathrm{d}\mathrm{e}\mathrm{t}(V)=-1\end{array}\text{(43)}$$
当 $\text{rank}({\Sigma }_{xy})>m$ 时，最变换参数为：
$$\begin{array}{rl}R& =US{V}^{\top }\text{(40)}\\ t& ={\mu }_y-cR{\mu }_x\text{(41)}\\ c& =\frac{1}{{\sigma }_x^2}\mathrm{t}\mathrm{r}(DS)\text{(42)}\end{array}$$

s临时保存。

    # Eq. (40) and (43).
    rank = np.linalg.matrix_rank(A)
    if rank == 0:
        return np.nan * T
    elif rank == dim - 1:
        if np.linalg.det(U) * np.linalg.det(V) > 0:
            T[:dim, :dim] = U @ V
        else:
            s = d[dim - 1]
            d[dim - 1] = -1
            T[:dim, :dim] = U @ np.diag(d) @ V
            d[dim - 1] = s
    else:
        T[:dim, :dim] = U @ np.diag(d) @ V

• 首先计算尺度参数 $c$ (公式42)；
• 然后计算平移参数 $t$（公式41）；
• 最后旋转参数 $R$ 和尺度参数 $c$ 融合到一起。

T的形式为：
$$\left[\begin{array}{ccc}s\cos (\theta )& \sin (\theta )& t_x\\ \sin (\theta )& s\cos (\theta )& t_y\\ 0& 0& 1\end{array}\right]$$

    if estimate_scale:
        # Eq. (41) and (42).
        scale = 1.0 / src_demean.var(axis=0).sum() * (S @ d)
    else:
        scale = 1.0

    T[:dim, dim] = dst_mean - scale * (T[:dim, :dim] @ src_mean.T)
    T[:dim, :dim] *= scale

    return T

参考资料：

• What does the “at” (@) symbol do in Python?
• face alignment[Ordinary Procrustes Analysis]
• Similarity (geometry)
• How does dlib face aligment works? #1382
• 传统算法和深度学习的结合和实践，解读与优化 deepfake
• Umeyama算法
• similarity transform matrix in c++ is different from python #481
• C++ using
• 4.3 Planar Graphs
• Find All Cycles (Faces) In a Graph
• Chinese Whispers
• Chinese Whispers - an Efficient Graph Clustering Algorithm and its Application to Natural Language Processing Problems
• Applying Affine transform on an image using dlib
• dlib人脸关键点代码解析
• Get Face Landmarks
• dlib人脸对齐源码详解
• dlib 人脸对齐 基本原理
• 对mtcnn的人脸对齐的理解
• Review of similarity transformation and Singular Value Decomposition
• 图像的等距变换，相似变换，仿射变换，射影变换及其matlab实现
• skimage库的transform.SimilarityTransform()用法
• How to compute the similarity transformation matrix
• Average Face : OpenCV ( C++ / Python ) Tutorial
• SimilarityTransform
• Aligning Face Images
• Face Alignment
• face alignment algorithm on images
• dlib数据结构matrix
• Dlib源码解析之一 matrix和array2d和image_view
• Dlib Element Specific Operations
• maketform
• dlib.net/matrix_ex.cpp
• deepfakes/faceswap/lib/umeyama.py
• ethz-asl/maplab/test/end-to-end-common/python/end_to_end_common/umeyama.py
• CarloNicolini/ralign
• Singular Value Decomposition (SVD) tutorial