mirror of
https://github.com/iperov/DeepFaceLab.git
synced 2024-12-25 07:21:13 -08:00
98 lines
2.6 KiB
Python
98 lines
2.6 KiB
Python
import math
|
|
|
|
import cv2
|
|
import numpy as np
|
|
import numpy.linalg as npla
|
|
|
|
from .umeyama import umeyama
|
|
|
|
|
|
def get_power_of_two(x):
|
|
i = 0
|
|
while (1 << i) < x:
|
|
i += 1
|
|
return i
|
|
|
|
def rotationMatrixToEulerAngles(R) :
|
|
sy = math.sqrt(R[0,0] * R[0,0] + R[1,0] * R[1,0])
|
|
singular = sy < 1e-6
|
|
if not singular :
|
|
x = math.atan2(R[2,1] , R[2,2])
|
|
y = math.atan2(-R[2,0], sy)
|
|
z = math.atan2(R[1,0], R[0,0])
|
|
else :
|
|
x = math.atan2(-R[1,2], R[1,1])
|
|
y = math.atan2(-R[2,0], sy)
|
|
z = 0
|
|
return np.array([x, y, z])
|
|
|
|
def polygon_area(x,y):
|
|
return 0.5*np.abs(np.dot(x,np.roll(y,1))-np.dot(y,np.roll(x,1)))
|
|
|
|
def rotate_point(origin, point, deg):
|
|
"""
|
|
Rotate a point counterclockwise by a given angle around a given origin.
|
|
|
|
The angle should be given in radians.
|
|
"""
|
|
ox, oy = origin
|
|
px, py = point
|
|
|
|
rad = deg * math.pi / 180.0
|
|
qx = ox + math.cos(rad) * (px - ox) - math.sin(rad) * (py - oy)
|
|
qy = oy + math.sin(rad) * (px - ox) + math.cos(rad) * (py - oy)
|
|
return np.float32([qx, qy])
|
|
|
|
def transform_points(points, mat, invert=False):
|
|
if invert:
|
|
mat = cv2.invertAffineTransform (mat)
|
|
points = np.expand_dims(points, axis=1)
|
|
points = cv2.transform(points, mat, points.shape)
|
|
points = np.squeeze(points)
|
|
return points
|
|
|
|
|
|
def transform_mat(mat, res, tx, ty, rotation, scale):
|
|
"""
|
|
transform mat in local space of res
|
|
scale -> translate -> rotate
|
|
|
|
tx,ty float
|
|
rotation int degrees
|
|
scale float
|
|
"""
|
|
|
|
|
|
lt, rt, lb, ct = transform_points ( np.float32([(0,0),(res,0),(0,res),(res / 2, res/2) ]),mat, True)
|
|
|
|
hor_v = (rt-lt).astype(np.float32)
|
|
hor_size = npla.norm(hor_v)
|
|
hor_v /= hor_size
|
|
|
|
ver_v = (lb-lt).astype(np.float32)
|
|
ver_size = npla.norm(ver_v)
|
|
ver_v /= ver_size
|
|
|
|
bt_diag_vec = (rt-ct).astype(np.float32)
|
|
half_diag_len = npla.norm(bt_diag_vec)
|
|
bt_diag_vec /= half_diag_len
|
|
|
|
tb_diag_vec = np.float32( [ -bt_diag_vec[1], bt_diag_vec[0] ] )
|
|
|
|
rt = ct + bt_diag_vec*half_diag_len*scale
|
|
lb = ct - bt_diag_vec*half_diag_len*scale
|
|
lt = ct - tb_diag_vec*half_diag_len*scale
|
|
|
|
rt[0] += tx*hor_size
|
|
lb[0] += tx*hor_size
|
|
lt[0] += tx*hor_size
|
|
rt[1] += ty*ver_size
|
|
lb[1] += ty*ver_size
|
|
lt[1] += ty*ver_size
|
|
|
|
rt = rotate_point(ct, rt, rotation)
|
|
lb = rotate_point(ct, lb, rotation)
|
|
lt = rotate_point(ct, lt, rotation)
|
|
|
|
return cv2.getAffineTransform( np.float32([lt, rt, lb]), np.float32([ [0,0], [res,0], [0,res] ]) )
|