对mtcnn的人脸对齐的理解
概念理解
人脸识的流程：人脸检测 ——人脸对齐——特征提取——相似度对比
人脸对齐也是关键的一步，在不同的应用场景下，会直接影响到人脸识别的结果。因为是否进行人脸对齐，会影响到提取到的特征，对齐前后提取到的特征是有差别的。
人脸对齐（矫正）：就是检测到人脸角度不正，关键点不对齐，然后需要对齐操作。
人脸对齐前后的效果对比如下图，发现对齐后效果还是挺好的。
那么我们要怎么实施人脸对齐呢？大致的思路是：先设定一个src作为标准的人脸关键点的位置，然后和我们检测到的人脸关键点dst进行相似变换，变换的过程包括旋转、平移、缩放，这样就得到一个齐次变换矩阵M，然后把M作为参数进行仿射变换得到对齐后的人脸图片。
代码
可以结合下代码做更好的理解：
def preprocess(img, bbox=None, landmark=None, **kwargs):
if isinstance(img, str): # 判断一个对象是否是一个已知的类型，类似type()
img = read_image(img, **kwargs)
M = None
image_size = []
str_image_size = kwargs.get('image_size', '')
if len(str_image_size)>0: # 得到图片的image_size，这里用112x112
image_size = [int(x) for x in str_image_size.split(',')]
if len(image_size)==1:
image_size = [image_size[0], image_size[0]]
assert len(image_size)==2
assert image_size[0]==112
assert image_size[0]==112 or image_size[1]==96
if landmark is not None: # 如果landmark不为none，就计算出M
assert len(image_size)==2
src = np.array([ # 人脸的5个关键点的位置，是固定的
[30.2946, 51.6963],
[65.5318, 51.5014],
[48.0252, 71.7366],
[33.5493, 92.3655],
[62.7299, 92.2041] ], dtype=np.float32 )
if image_size[1]==112: # 如果为112，则要把这些坐标的横坐标都加上8.0
src[:,0] += 8.0 # 那么8.0是怎么计算的呢？(112-96)/2 = 8.0
dst = landmark.astype(np.float32) # 目标关键点，设置一下它的数据类型
tform = trans.SimilarityTransform() # 引用 class SimilarityTransform()
tform.estimate(dst, src) # 从一组对应的点估计转换
M = tform.params[0:2,:] # 得到(3, 3) 的齐次变换矩阵
#M = cv2.estimateRigidTransform( dst.reshape(1,5,2), src.reshape(1,5,2), False)
if M is None: # 如果通过上面的变换没有找到齐次变换矩阵，就用以下的方法来调整bbox
if bbox is None: #use center crop # 如果没有bbox，用中心来进行裁剪
det = np.zeros(4, dtype=np.int32)
det[0] = int(img.shape[1]*0.0625)
det[1] = int(img.shape[0]*0.0625)
det[2] = img.shape[1] - det[0]
det[3] = img.shape[0] - det[1]
else: # 直接使用bbox
det = bbox
margin = kwargs.get('margin', 44) # margin的值一般为0.2，表示两个类之间的间距
bb = np.zeros(4, dtype=np.int32) # 4个关键点坐标
bb[0] = np.maximum(det[0]-margin/2, 0)
bb[1] = np.maximum(det[1]-margin/2, 0)
bb[2] = np.minimum(det[2]+margin/2, img.shape[1])
bb[3] = np.minimum(det[3]+margin/2, img.shape[0])
ret = img[bb[1]:bb[3],bb[0]:bb[2],:] # 得到4个关键点坐标
if len(image_size)>0:
ret = cv2.resize(ret, (image_size[1], image_size[0])) # 图片缩放到112
return ret
else: #do align using landmark
assert len(image_size)==2
#src = src[0:3,:]
#dst = dst[0:3,:]
#print(src.shape, dst.shape)
#print(src)
#print(dst)
#print(M)
warped = cv2.warpAffine(img,M,(image_size[1],image_size[0]), borderValue = 0.0) # 进行仿射变换
#tform3 = trans.ProjectiveTransform()
#tform3.estimate(src, dst)
#warped = trans.warp(img, tform3, output_shape=_shape)
return warped
class SimilarityTransform(EuclideanTransform):
"""2D similarity transformation of the form:
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
where ``s`` is a scale factor and the homogeneous transformation matrix is::
[[a0 b0 a1]
[b0 a0 b1]
[0 0 1]]
The similarity transformation extends the Euclidean transformation with a
single scaling factor in addition to the rotation and translation
parameters.
Parameters
----------
matrix : (3, 3) array, optional
Homogeneous transformation matrix.
scale : float, optional
Scale factor.
rotation : float, optional
Rotation angle in counter-clockwise direction as radians.
translation : (tx, ty) as array, list or tuple, optional
x, y translation parameters.
Attributes
----------
params : (3, 3) array
Homogeneous transformation matrix.
"""
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)
def estimate(self, src, dst):
"""Estimate the transformation from a set of corresponding points.
You can determine the over-, well- and under-determined parameters
with the total least-squares method.
Number of source and destination coordinates must match.
Parameters
----------
src : (N, 2) array
Source coordinates.
dst : (N, 2) array
Destination coordinates.
Returns
-------
success : bool
True, if model estimation succeeds.
"""
self.params = _umeyama(src, dst, True)
return True
@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
2维相似度变换公式：
公式中s是缩放因子，齐次变换矩阵是
[[a0 b0 a1]
[b0 a0 b1]
[0 0 1 ]]
参数：
matrix : (3, 3) 数组，可选的齐次变换矩阵
scale : 缩放因子
rotation : 逆时针旋转角度为弧度
translation : (tx, ty) 是一个 array, list or tuple, 转换参数
params : (3, 3) 数组，齐次变换矩阵
除了旋转和平移参数外，相似变换还扩展了具有单个比例因子的欧几里得变换。从一组相应的点估计转换，可以使用总最小二乘法确定过、好和欠的参数，且要求源坐标和目标坐标的数量必须匹配。