808 lines
29 KiB
Python
808 lines
29 KiB
Python
# convert mediapipe model to model from Unreal
|
|
|
|
import numpy as np
|
|
|
|
# create the element of json
|
|
def makexyzrotvis(x,y,z,rotx,roty,rotz,visible):
|
|
ret = {}
|
|
translation = {}
|
|
rotation = {}
|
|
scale = {}
|
|
translation["x"] = x
|
|
translation["y"] = y
|
|
translation["z"] = z
|
|
rotation["rotx"] = rotx
|
|
rotation["roty"] = roty
|
|
rotation["rotz"] = rotz
|
|
scale["x"] = 1.0
|
|
scale["y"] = 1.0
|
|
scale["z"] = 1.0
|
|
ret["visible"] = visible
|
|
ret["translation"] = translation
|
|
ret["rotation"] = rotation
|
|
ret["scale"] = scale
|
|
return ret
|
|
|
|
def getAngle(avec0, avec1, bvec0, bvec1):
|
|
chis = float(avec0*bvec0 + avec1*bvec1)
|
|
znam1 = float(np.sqrt(pow(avec0, 2) + pow(avec1, 2)))
|
|
znam2 = float(np.sqrt(pow(bvec0, 2) + pow(bvec1, 2)))
|
|
if (znam1*znam2) == 0 or np.fabs(chis) > np.fabs(znam1*znam2):
|
|
return None
|
|
return np.arccos(chis / (znam1 * znam2)) * 180. / np.pi
|
|
|
|
def getVecNorm(vec):
|
|
length = np.sqrt(pow(vec[0],2)+pow(vec[1],2)+pow(vec[2],2))
|
|
vec_norm = [vec[0]/length,
|
|
vec[1]/length,
|
|
vec[2]/length]
|
|
return vec_norm
|
|
|
|
def getRotaionVect(vec1, vec2):
|
|
vec1_norm = getVecNorm(vec1)
|
|
vec2_norm = getVecNorm(vec2)
|
|
cr = np.cross(vec1_norm, vec2_norm)
|
|
length = np.sqrt(pow(cr[0],2)+pow(cr[1],2)+pow(cr[2],2))
|
|
cr[0] /= length
|
|
cr[1] /= length
|
|
cr[2] /= length
|
|
angle = np.arccos(np.dot(vec1_norm, vec2_norm))
|
|
return (cr[0],cr[1],cr[2],angle)
|
|
|
|
def toEuler(x, y, z, angle):
|
|
s = np.sin(angle)
|
|
c = np.cos(angle)
|
|
t = 1-c
|
|
if ((x*y*t + z*s) > 0.998):
|
|
heading = 2*np.arctan2(x*np.sin(angle/2),np.cos(angle/2))
|
|
attitude = np.pi/2
|
|
bank = 0
|
|
heading *= 180 / np.pi
|
|
attitude *= 180 / np.pi
|
|
bank *= 180 / np.pi
|
|
return (heading, attitude, bank)
|
|
if ((x*y*t + z*s) < -0.998):
|
|
heading = -2*np.arctan2(x*np.sin(angle/2),np.cos(angle/2))
|
|
attitude = -np.pi/2
|
|
bank = 0
|
|
heading *= 180 / np.pi
|
|
attitude *= 180 / np.pi
|
|
bank *= 180 / np.pi
|
|
return (heading, attitude, bank)
|
|
heading = np.arctan2(y * s- x * z * t , 1 - (y*y+ z*z ) * t)
|
|
attitude = np.arcsin(x * y * t + z * s)
|
|
bank = np.arctan2(x * s - y * z * t , 1 - (x*x + z*z) * t)
|
|
heading *= 180 / np.pi
|
|
attitude *= 180 / np.pi
|
|
bank *= 180 / np.pi
|
|
return (heading, attitude, bank)
|
|
|
|
def lfingerRot(current, child, data, dataxyz):
|
|
vec2 = [dataxyz[child][0] - dataxyz[current][0],
|
|
dataxyz[child][1] - dataxyz[current][1],
|
|
dataxyz[child][2] - dataxyz[current][2]]
|
|
vec1 = [1, 0, 0]
|
|
|
|
rotvec = getRotaionVect(vec1, vec2)
|
|
euler = toEuler(rotvec[0], rotvec[1], rotvec[2], rotvec[3])
|
|
|
|
data[current]["rotation"]["rotx"] = -euler[0]
|
|
data[current]["rotation"]["roty"] = euler[1]
|
|
data[current]["rotation"]["rotz"] = -90
|
|
|
|
def lhandRot(current, child, data, dataxyz, support1, support2):
|
|
vec2 = [dataxyz[child][0] - dataxyz[current][0],
|
|
dataxyz[child][1] - dataxyz[current][1],
|
|
dataxyz[child][2] - dataxyz[current][2]]
|
|
vec1 = [1, 0, 0]
|
|
|
|
rotvec = getRotaionVect(vec1, vec2)
|
|
euler = toEuler(rotvec[0],rotvec[1],rotvec[2],rotvec[3])
|
|
# print(euler)
|
|
|
|
vec3 = [dataxyz[support2][0] - dataxyz[support1][0],
|
|
dataxyz[support2][1] - dataxyz[support1][1],
|
|
dataxyz[support2][2] - dataxyz[support1][2]]
|
|
|
|
vec2_norm = getVecNorm(vec2)
|
|
vec3_norm = getVecNorm(vec3)
|
|
sup2 = np.cross(vec2_norm, vec3_norm)
|
|
sup2_norm = getVecNorm(sup2)
|
|
sup1 = [0, 1, 0]
|
|
sup1_norm = getVecNorm(sup1)
|
|
|
|
rotsup = getRotaionVect(sup1_norm, sup2_norm)
|
|
euler_sup = toEuler(rotsup[0], rotsup[1], rotsup[2], rotsup[3])
|
|
# print(euler_sup)
|
|
|
|
data[current]["rotation"]["rotx"] = -euler[0]
|
|
data[current]["rotation"]["roty"] = euler[1]
|
|
data[current]["rotation"]["rotz"] = -euler_sup[2]
|
|
|
|
def lhandeuler(lhandlms, data, coef):
|
|
dataxyz = {}
|
|
|
|
rootx = lhandlms[17].x * coef
|
|
rooty = -lhandlms[17].z * coef
|
|
rootz = -lhandlms[17].y * coef
|
|
rootv = 1.0
|
|
dataxyz["pinky_2_l"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = lhandlms[18].x * coef
|
|
rooty = -lhandlms[18].z * coef
|
|
rootz = -lhandlms[18].y * coef
|
|
rootv = 1.0
|
|
dataxyz["pinky_3_l"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = lhandlms[19].x * coef
|
|
rooty = -lhandlms[19].z * coef
|
|
rootz = -lhandlms[19].y * coef
|
|
rootv = 1.0
|
|
dataxyz["pinky_4_l"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = lhandlms[20].x * coef
|
|
rooty = -lhandlms[20].z * coef
|
|
rootz = -lhandlms[20].y * coef
|
|
rootv = 1.0
|
|
dataxyz["pinky_5_l"] = [rootx, rooty, rootz, rootv]
|
|
|
|
lfingerRot("pinky_2_l", "pinky_3_l", data, dataxyz)
|
|
lfingerRot("pinky_3_l", "pinky_4_l", data, dataxyz)
|
|
lfingerRot("pinky_4_l", "pinky_5_l", data, dataxyz)
|
|
|
|
rootx = lhandlms[13].x * coef
|
|
rooty = -lhandlms[13].z * coef
|
|
rootz = -lhandlms[13].y * coef
|
|
rootv = 1.0
|
|
dataxyz["ring_2_l"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = lhandlms[14].x * coef
|
|
rooty = -lhandlms[14].z * coef
|
|
rootz = -lhandlms[14].y * coef
|
|
rootv = 1.0
|
|
dataxyz["ring_3_l"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = lhandlms[15].x * coef
|
|
rooty = -lhandlms[15].z * coef
|
|
rootz = -lhandlms[15].y * coef
|
|
rootv = 1.0
|
|
dataxyz["ring_4_l"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = lhandlms[16].x * coef
|
|
rooty = -lhandlms[16].z * coef
|
|
rootz = -lhandlms[16].y * coef
|
|
rootv = 1.0
|
|
dataxyz["ring_5_l"] = [rootx, rooty, rootz, rootv]
|
|
|
|
lfingerRot("ring_2_l", "ring_3_l", data, dataxyz)
|
|
lfingerRot("ring_3_l", "ring_4_l", data, dataxyz)
|
|
lfingerRot("ring_4_l", "ring_5_l", data, dataxyz)
|
|
|
|
rootx = lhandlms[9].x * coef
|
|
rooty = -lhandlms[9].z * coef
|
|
rootz = -lhandlms[9].y * coef
|
|
rootv = 1.0
|
|
dataxyz["middle_2_l"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = lhandlms[10].x * coef
|
|
rooty = -lhandlms[10].z * coef
|
|
rootz = -lhandlms[10].y * coef
|
|
rootv = 1.0
|
|
dataxyz["middle_3_l"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = lhandlms[11].x * coef
|
|
rooty = -lhandlms[11].z * coef
|
|
rootz = -lhandlms[11].y * coef
|
|
rootv = 1.0
|
|
dataxyz["middle_4_l"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = lhandlms[12].x * coef
|
|
rooty = -lhandlms[12].z * coef
|
|
rootz = -lhandlms[12].y * coef
|
|
rootv = 1.0
|
|
dataxyz["middle_5_l"] = [rootx, rooty, rootz, rootv]
|
|
|
|
lfingerRot("middle_2_l", "middle_3_l", data, dataxyz)
|
|
lfingerRot("middle_3_l", "middle_4_l", data, dataxyz)
|
|
lfingerRot("middle_4_l", "middle_5_l", data, dataxyz)
|
|
|
|
rootx = lhandlms[5].x * coef
|
|
rooty = -lhandlms[5].z * coef
|
|
rootz = -lhandlms[5].y * coef
|
|
rootv = 1.0
|
|
dataxyz["index_2_l"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = lhandlms[6].x * coef
|
|
rooty = -lhandlms[6].z * coef
|
|
rootz = -lhandlms[6].y * coef
|
|
rootv = 1.0
|
|
dataxyz["index_3_l"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = lhandlms[7].x * coef
|
|
rooty = -lhandlms[7].z * coef
|
|
rootz = -lhandlms[7].y * coef
|
|
rootv = 1.0
|
|
dataxyz["index_4_l"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = lhandlms[8].x * coef
|
|
rooty = -lhandlms[8].z * coef
|
|
rootz = -lhandlms[8].y * coef
|
|
rootv = 1.0
|
|
dataxyz["index_5_l"] = [rootx, rooty, rootz, rootv]
|
|
|
|
lfingerRot("index_2_l", "index_3_l", data, dataxyz)
|
|
lfingerRot("index_3_l", "index_4_l", data, dataxyz)
|
|
lfingerRot("index_4_l", "index_5_l", data, dataxyz)
|
|
|
|
rootx = lhandlms[1].x * coef
|
|
rooty = -lhandlms[1].z * coef
|
|
rootz = -lhandlms[1].y * coef
|
|
rootv = 1.0
|
|
dataxyz["thumb_2_l"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = lhandlms[2].x * coef
|
|
rooty = -lhandlms[2].z * coef
|
|
rootz = -lhandlms[2].y * coef
|
|
rootv = 1.0
|
|
dataxyz["thumb_3_l"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = lhandlms[3].x * coef
|
|
rooty = -lhandlms[3].z * coef
|
|
rootz = -lhandlms[3].y * coef
|
|
rootv = 1.0
|
|
dataxyz["thumb_4_l"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = lhandlms[4].x * coef
|
|
rooty = -lhandlms[4].z * coef
|
|
rootz = -lhandlms[4].y * coef
|
|
rootv = 1.0
|
|
dataxyz["thumb_5_l"] = [rootx, rooty, rootz, rootv]
|
|
|
|
lfingerRot("thumb_2_l", "thumb_3_l", data, dataxyz)
|
|
lfingerRot("thumb_3_l", "thumb_4_l", data, dataxyz)
|
|
lfingerRot("thumb_4_l", "thumb_5_l", data, dataxyz)
|
|
|
|
rootx = lhandlms[0].x * coef
|
|
rooty = -lhandlms[0].z * coef
|
|
rootz = -lhandlms[0].y * coef
|
|
rootv = 1.0
|
|
dataxyz["hand_l"] = [rootx, rooty, rootz, rootv]
|
|
|
|
lhandRot("hand_l", "middle_2_l", data, dataxyz, "pinky_2_l", "index_2_l")
|
|
|
|
def rhandRot(current, child, data, dataxyz, support1, support2):
|
|
vec2 = [dataxyz[child][0] - dataxyz[current][0],
|
|
dataxyz[child][1] - dataxyz[current][1],
|
|
dataxyz[child][2] - dataxyz[current][2]]
|
|
vec1 = [-1, 0, 0]
|
|
|
|
rotvec = getRotaionVect(vec1, vec2)
|
|
euler = toEuler(rotvec[0],rotvec[1],rotvec[2],rotvec[3])
|
|
# print(euler)
|
|
|
|
vec3 = [dataxyz[support2][0] - dataxyz[support1][0],
|
|
dataxyz[support2][1] - dataxyz[support1][1],
|
|
dataxyz[support2][2] - dataxyz[support1][2]]
|
|
|
|
vec2_norm = getVecNorm(vec2)
|
|
vec3_norm = getVecNorm(vec3)
|
|
sup2 = np.cross(vec2_norm, vec3_norm)
|
|
sup2_norm = getVecNorm(sup2)
|
|
sup1 = [0, 1, 0]
|
|
sup1_norm = getVecNorm(sup1)
|
|
|
|
rotsup = getRotaionVect(sup1_norm, sup2_norm)
|
|
euler_sup = toEuler(rotsup[0], rotsup[1], rotsup[2], rotsup[3])
|
|
# print(euler_sup)
|
|
|
|
data[current]["rotation"]["rotx"] = -euler[0]
|
|
data[current]["rotation"]["roty"] = euler[1]
|
|
data[current]["rotation"]["rotz"] = -euler_sup[2]
|
|
|
|
def rfingerRot(current, child, data, dataxyz):
|
|
vec2 = [dataxyz[child][0] - dataxyz[current][0],
|
|
dataxyz[child][1] - dataxyz[current][1],
|
|
dataxyz[child][2] - dataxyz[current][2]]
|
|
vec1 = [-1, 0, 0]
|
|
|
|
rotvec = getRotaionVect(vec1, vec2)
|
|
euler = toEuler(rotvec[0], rotvec[1], rotvec[2], rotvec[3])
|
|
|
|
data[current]["rotation"]["rotx"] = -euler[0]
|
|
data[current]["rotation"]["roty"] = euler[1]
|
|
data[current]["rotation"]["rotz"] = 90
|
|
|
|
def rhandeuler(rhandlms, data, coef):
|
|
dataxyz = {}
|
|
|
|
rootx = rhandlms[17].x * coef
|
|
rooty = -rhandlms[17].z * coef
|
|
rootz = -rhandlms[17].y * coef
|
|
rootv = 1.0
|
|
dataxyz["pinky_2_r"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = rhandlms[18].x * coef
|
|
rooty = -rhandlms[18].z * coef
|
|
rootz = -rhandlms[18].y * coef
|
|
rootv = 1.0
|
|
dataxyz["pinky_3_r"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = rhandlms[19].x * coef
|
|
rooty = -rhandlms[19].z * coef
|
|
rootz = -rhandlms[19].y * coef
|
|
rootv = 1.0
|
|
dataxyz["pinky_4_r"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = rhandlms[20].x * coef
|
|
rooty = -rhandlms[20].z * coef
|
|
rootz = -rhandlms[20].y * coef
|
|
rootv = 1.0
|
|
dataxyz["pinky_5_r"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rfingerRot("pinky_2_r", "pinky_3_r", data, dataxyz)
|
|
rfingerRot("pinky_3_r", "pinky_4_r", data, dataxyz)
|
|
rfingerRot("pinky_4_r", "pinky_5_r", data, dataxyz)
|
|
|
|
rootx = rhandlms[13].x * coef
|
|
rooty = -rhandlms[13].z * coef
|
|
rootz = -rhandlms[13].y * coef
|
|
rootv = 1.0
|
|
dataxyz["ring_2_r"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = rhandlms[14].x * coef
|
|
rooty = -rhandlms[14].z * coef
|
|
rootz = -rhandlms[14].y * coef
|
|
rootv = 1.0
|
|
dataxyz["ring_3_r"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = rhandlms[15].x * coef
|
|
rooty = -rhandlms[15].z * coef
|
|
rootz = -rhandlms[15].y * coef
|
|
rootv = 1.0
|
|
dataxyz["ring_4_r"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = rhandlms[16].x * coef
|
|
rooty = -rhandlms[16].z * coef
|
|
rootz = -rhandlms[16].y * coef
|
|
rootv = 1.0
|
|
dataxyz["ring_5_r"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rfingerRot("ring_2_r", "ring_3_r", data, dataxyz)
|
|
rfingerRot("ring_3_r", "ring_4_r", data, dataxyz)
|
|
rfingerRot("ring_4_r", "ring_5_r", data, dataxyz)
|
|
|
|
rootx = rhandlms[9].x * coef
|
|
rooty = -rhandlms[9].z * coef
|
|
rootz = -rhandlms[9].y * coef
|
|
rootv = 1.0
|
|
dataxyz["middle_2_r"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = rhandlms[10].x * coef
|
|
rooty = -rhandlms[10].z * coef
|
|
rootz = -rhandlms[10].y * coef
|
|
rootv = 1.0
|
|
dataxyz["middle_3_r"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = rhandlms[11].x * coef
|
|
rooty = -rhandlms[11].z * coef
|
|
rootz = -rhandlms[11].y * coef
|
|
rootv = 1.0
|
|
dataxyz["middle_4_r"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = rhandlms[12].x * coef
|
|
rooty = -rhandlms[12].z * coef
|
|
rootz = -rhandlms[12].y * coef
|
|
rootv = 1.0
|
|
dataxyz["middle_5_r"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rfingerRot("middle_2_r", "middle_3_r", data, dataxyz)
|
|
rfingerRot("middle_3_r", "middle_4_r", data, dataxyz)
|
|
rfingerRot("middle_4_r", "middle_5_r", data, dataxyz)
|
|
|
|
rootx = rhandlms[5].x * coef
|
|
rooty = -rhandlms[5].z * coef
|
|
rootz = -rhandlms[5].y * coef
|
|
rootv = 1.0
|
|
dataxyz["index_2_r"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = rhandlms[6].x * coef
|
|
rooty = -rhandlms[6].z * coef
|
|
rootz = -rhandlms[6].y * coef
|
|
rootv = 1.0
|
|
dataxyz["index_3_r"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = rhandlms[7].x * coef
|
|
rooty = -rhandlms[7].z * coef
|
|
rootz = -rhandlms[7].y * coef
|
|
rootv = 1.0
|
|
dataxyz["index_4_r"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = rhandlms[8].x * coef
|
|
rooty = -rhandlms[8].z * coef
|
|
rootz = -rhandlms[8].y * coef
|
|
rootv = 1.0
|
|
dataxyz["index_5_r"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rfingerRot("index_2_r", "index_3_r", data, dataxyz)
|
|
rfingerRot("index_3_r", "index_4_r", data, dataxyz)
|
|
rfingerRot("index_4_r", "index_5_r", data, dataxyz)
|
|
|
|
rootx = rhandlms[1].x * coef
|
|
rooty = -rhandlms[1].z * coef
|
|
rootz = -rhandlms[1].y * coef
|
|
rootv = 1.0
|
|
dataxyz["thumb_2_r"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = rhandlms[2].x * coef
|
|
rooty = -rhandlms[2].z * coef
|
|
rootz = -rhandlms[2].y * coef
|
|
rootv = 1.0
|
|
dataxyz["thumb_3_r"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = rhandlms[3].x * coef
|
|
rooty = -rhandlms[3].z * coef
|
|
rootz = -rhandlms[3].y * coef
|
|
rootv = 1.0
|
|
dataxyz["thumb_4_r"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = rhandlms[4].x * coef
|
|
rooty = -rhandlms[4].z * coef
|
|
rootz = -rhandlms[4].y * coef
|
|
rootv = 1.0
|
|
dataxyz["thumb_5_r"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rfingerRot("thumb_2_r", "thumb_3_r", data, dataxyz)
|
|
rfingerRot("thumb_3_r", "thumb_4_r", data, dataxyz)
|
|
rfingerRot("thumb_4_r", "thumb_5_r", data, dataxyz)
|
|
|
|
rootx = rhandlms[0].x * coef
|
|
rooty = -rhandlms[0].z * coef
|
|
rootz = -rhandlms[0].y * coef
|
|
rootv = 1.0
|
|
dataxyz["hand_r"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rhandRot("hand_r", "middle_2_r", data, dataxyz, "pinky_2_r", "index_2_r")
|
|
|
|
def boneRot(current, child, data, dataxyz, vec1, zangle):
|
|
vec2 = [dataxyz[child][0] - dataxyz[current][0],
|
|
dataxyz[child][1] - dataxyz[current][1],
|
|
dataxyz[child][2] - dataxyz[current][2]]
|
|
# vec1 = [-1, 0, 0]
|
|
|
|
rotvec = getRotaionVect(vec1, vec2)
|
|
euler = toEuler(rotvec[0], rotvec[1], rotvec[2], rotvec[3])
|
|
|
|
data[current]["rotation"]["rotx"] = -euler[0]
|
|
data[current]["rotation"]["roty"] = euler[1]
|
|
data[current]["rotation"]["rotz"] = zangle
|
|
|
|
if np.fabs(data[current]["rotation"]["rotx"])>90:
|
|
data[current]["rotation"]["roty"] *= -1
|
|
|
|
def spineRot(current, child0, child, data, dataxyz, support1, support2):
|
|
vec2 = [dataxyz[child][0] - dataxyz[child0][0],
|
|
dataxyz[child][1] - dataxyz[child0][1],
|
|
dataxyz[child][2] - dataxyz[child0][2]]
|
|
vec1 = [1, 0, 0]
|
|
|
|
rotvec = getRotaionVect(vec1, vec2)
|
|
euler = toEuler(rotvec[0],rotvec[1],rotvec[2],rotvec[3])
|
|
# print(euler)
|
|
|
|
vec3 = [dataxyz[support2][0] - dataxyz[support1][0],
|
|
dataxyz[support2][1] - dataxyz[support1][1],
|
|
dataxyz[support2][2] - dataxyz[support1][2]]
|
|
|
|
vec2_norm = getVecNorm(vec2)
|
|
vec3_norm = getVecNorm(vec3)
|
|
sup2 = np.cross(vec2_norm, vec3_norm)
|
|
sup2_norm = getVecNorm(sup2)
|
|
sup1 = [0, -1, 0]
|
|
sup1_norm = getVecNorm(sup1)
|
|
|
|
rotsup = getRotaionVect(sup1_norm, sup2_norm)
|
|
euler_sup = toEuler(rotsup[0], rotsup[1], rotsup[2], rotsup[3])
|
|
# print(euler_sup)
|
|
|
|
# print(euler_sup)
|
|
# data[current]["rotation"]["rotz"] = 0
|
|
data[current]["rotation"]["rotx"] = 90#-euler_sup[2]+45
|
|
data[current]["rotation"]["roty"] = euler_sup[1]-90
|
|
if data[current]["rotation"]["roty"] <= -180:
|
|
data[current]["rotation"]["roty"] += 180
|
|
data[current]["rotation"]["rotz"] = euler[0]
|
|
|
|
def headRot(current, pp1_0, pp1_1, pp2_0, pp2_1, data, dataxyz):
|
|
vec2 = [dataxyz[pp1_1][0] - dataxyz[pp1_0][0],
|
|
0,
|
|
dataxyz[pp1_1][2] - dataxyz[pp1_0][2]]
|
|
vec1 = [1, 0, 0]
|
|
|
|
vec2_norm = getVecNorm(vec2)
|
|
|
|
rotvec = getRotaionVect(vec1, vec2_norm)
|
|
euler1 = toEuler(rotvec[0], rotvec[1], rotvec[2], rotvec[3])
|
|
|
|
vec2 = [dataxyz[pp2_1][0] - dataxyz[pp2_0][0],
|
|
dataxyz[pp2_1][1] - dataxyz[pp2_0][1],
|
|
dataxyz[pp2_1][2] - dataxyz[pp2_0][2]]
|
|
vec1 = [0, 1, 0]
|
|
|
|
vec2_norm = getVecNorm(vec2)
|
|
rotvec = getRotaionVect(vec1, vec2_norm)
|
|
euler2 = toEuler(rotvec[0], rotvec[1], rotvec[2], rotvec[3])
|
|
|
|
# print(euler1)
|
|
# print(euler)
|
|
data[current]["rotation"]["rotx"] = euler2[2] + 90
|
|
if data[current]["rotation"]["rotx"] > 180:
|
|
data[current]["rotation"]["rotx"] -= 180
|
|
data[current]["rotation"]["roty"] = -euler1[0]
|
|
data[current]["rotation"]["rotz"] = -euler2[1] + 90
|
|
if data[current]["rotation"]["rotz"] > 180:
|
|
data[current]["rotation"]["rotz"] -= 180
|
|
|
|
def bodyeuler(poselms, data, coef):
|
|
dataxyz = {}
|
|
|
|
rootx = poselms[24].x * coef
|
|
rooty = -poselms[24].z * coef
|
|
rootz = -poselms[24].y * coef
|
|
rootv = poselms[24].visibility
|
|
# data["hip_r"] = makexyzrotvis(rootx, rooty, rootz, 0, 0, 0, rootv)
|
|
dataxyz["hip_r"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = poselms[23].x * coef
|
|
rooty = -poselms[23].z * coef
|
|
rootz = -poselms[23].y * coef
|
|
rootv = poselms[23].visibility
|
|
# data["hip_l"] = makexyzrotvis(rootx, rooty, rootz, 0, 0, 0, rootv)
|
|
dataxyz["hip_l"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = poselms[26].x * coef
|
|
rooty = -poselms[26].z * coef
|
|
rootz = -poselms[26].y * coef
|
|
rootv = poselms[26].visibility
|
|
dataxyz["knee_r"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = poselms[25].x * coef
|
|
rooty = -poselms[25].z * coef
|
|
rootz = -poselms[25].y * coef
|
|
rootv = poselms[25].visibility
|
|
dataxyz["knee_l"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = poselms[28].x * coef
|
|
rooty = -poselms[28].z * coef
|
|
rootz = -poselms[28].y * coef
|
|
rootv = poselms[28].visibility
|
|
dataxyz["ankle_r"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = poselms[27].x * coef
|
|
rooty = -poselms[27].z * coef
|
|
rootz = -poselms[27].y * coef
|
|
rootv = poselms[27].visibility
|
|
dataxyz["ankle_l"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = poselms[32].x * coef
|
|
rooty = -poselms[32].z * coef
|
|
rootz = -poselms[32].y * coef
|
|
rootv = poselms[32].visibility
|
|
dataxyz["ball_r"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = poselms[31].x * coef
|
|
rooty = -poselms[31].z * coef
|
|
rootz = -poselms[31].y * coef
|
|
rootv = poselms[31].visibility
|
|
dataxyz["ball_l"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = poselms[30].x * coef
|
|
rooty = -poselms[30].z * coef
|
|
rootz = -poselms[30].y * coef
|
|
rootv = poselms[30].visibility
|
|
data["heel_r"] = makexyzrotvis(rootx, rooty, rootz, 0, 0, 0, rootv)
|
|
dataxyz["heel_r"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = poselms[29].x * coef
|
|
rooty = -poselms[29].z * coef
|
|
rootz = -poselms[29].y * coef
|
|
rootv = poselms[29].visibility
|
|
data["heel_l"] = makexyzrotvis(rootx, rooty, rootz, 0, 0, 0, rootv)
|
|
dataxyz["heel_l"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = 0.5 * (dataxyz["hip_l"][0] + dataxyz["hip_r"][0])
|
|
rooty = 0.5 * (dataxyz["hip_l"][1] + dataxyz["hip_r"][1])
|
|
rootz = 0.5 * (dataxyz["hip_l"][2] + dataxyz["hip_r"][2])
|
|
rootv = 0.5 * (dataxyz["hip_l"][3] + dataxyz["hip_r"][3])
|
|
# data["pelvis"] = makexyzrotvis(rootx, rooty, rootz, 0, 0, 0, rootv)
|
|
dataxyz["pelvis"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = poselms[12].x * coef
|
|
rooty = -poselms[12].z * coef
|
|
rootz = -poselms[12].y * coef
|
|
rootv = 1.0
|
|
dataxyz["shoulder_r"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = poselms[14].x * coef
|
|
rooty = -poselms[14].z * coef
|
|
rootz = -poselms[14].y * coef
|
|
rootv = 1.0
|
|
dataxyz["elbow_r"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = poselms[16].x * coef
|
|
rooty = -poselms[16].z * coef
|
|
rootz = -poselms[16].y * coef
|
|
rootv = 1.0
|
|
dataxyz["hand_r"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = poselms[11].x * coef
|
|
rooty = -poselms[11].z * coef
|
|
rootz = -poselms[11].y * coef
|
|
rootv = 1.0
|
|
dataxyz["shoulder_l"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = poselms[13].x * coef
|
|
rooty = -poselms[13].z * coef
|
|
rootz = -poselms[13].y * coef
|
|
rootv = 1.0
|
|
dataxyz["elbow_l"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = poselms[15].x * coef
|
|
rooty = -poselms[15].z * coef
|
|
rootz = -poselms[15].y * coef
|
|
rootv = 1.0
|
|
dataxyz["hand_l"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = poselms[7].x * coef
|
|
rooty = -poselms[7].z * coef
|
|
rootz = -poselms[7].y * coef
|
|
rootv = 1.0
|
|
dataxyz["ear_l"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = poselms[8].x * coef
|
|
rooty = -poselms[8].z * coef
|
|
rootz = -poselms[8].y * coef
|
|
rootv = 1.0
|
|
dataxyz["ear_r"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = poselms[2].x * coef
|
|
rooty = -poselms[2].z * coef
|
|
rootz = -poselms[2].y * coef
|
|
rootv = 1.0
|
|
dataxyz["eye_l"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = poselms[5].x * coef
|
|
rooty = -poselms[5].z * coef
|
|
rootz = -poselms[5].y * coef
|
|
rootv = 1.0
|
|
dataxyz["eye_r"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = 0.5 * (dataxyz["ear_l"][0] + dataxyz["ear_r"][0])
|
|
rooty = 0.5 * (dataxyz["ear_l"][1] + dataxyz["ear_r"][1])
|
|
rootz = 0.5 * (dataxyz["ear_l"][2] + dataxyz["ear_r"][2])
|
|
rootv = 1.0
|
|
# data["head"] = makexyzrotvis(rootx, rooty, rootz, 0, 0, 0, rootv)
|
|
dataxyz["mid_ears"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = poselms[0].x * coef
|
|
rooty = -poselms[0].z * coef
|
|
rootz = -poselms[0].y * coef
|
|
rootv = 1.0
|
|
dataxyz["nose"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = 0.5 * (dataxyz["shoulder_l"][0] + dataxyz["shoulder_r"][0])
|
|
rooty = 0.5 * (dataxyz["shoulder_l"][1] + dataxyz["shoulder_r"][1])
|
|
rootz = -poselms[0].y * coef * 0.3 + 0.35 * (dataxyz["shoulder_l"][2] + dataxyz["shoulder_r"][2])
|
|
rootv = poselms[0].visibility
|
|
# data["head"] = makexyzrotvis(rootx, rooty, rootz, 0, 0, 0, rootv)
|
|
dataxyz["head"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = 0.5 * (dataxyz["shoulder_l"][0] + dataxyz["shoulder_r"][0])
|
|
rooty = 0.5 * (dataxyz["shoulder_l"][1] + dataxyz["shoulder_r"][1])
|
|
rootz = 0.5 * (dataxyz["shoulder_l"][2] + dataxyz["shoulder_r"][2])
|
|
rootv = 1.0
|
|
# data["head"] = makexyzrotvis(rootx, rooty, rootz, 0, 0, 0, rootv)
|
|
dataxyz["mid_shoulders"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = 0.5 * (dataxyz["ear_l"][0] + dataxyz["ear_r"][0])
|
|
rooty = 0.5 * (dataxyz["ear_l"][1] + dataxyz["ear_r"][1])
|
|
rootz = dataxyz["nose"][2]
|
|
rootv = poselms[0].visibility
|
|
# data["head"] = makexyzrotvis(rootx, rooty, rootz, 0, 0, 0, rootv)
|
|
dataxyz["head_nose"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = (0.044113 * dataxyz["head"][0] + 0.955887 * dataxyz["pelvis"][0])
|
|
rooty = (0.044113 * dataxyz["head"][1] + 0.955887 * dataxyz["pelvis"][1])
|
|
rootz = (0.044113 * dataxyz["head"][2] + 0.955887 * dataxyz["pelvis"][2])
|
|
rootv = (0.044113 * dataxyz["head"][3] + 0.955887 * dataxyz["pelvis"][3])
|
|
data["spine_01"] = makexyzrotvis(rootx, rooty, rootz, 0, 0, 0, rootv)
|
|
dataxyz["spine_01"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = (0.135799 * dataxyz["head"][0] + 0.864201 * dataxyz["pelvis"][0])
|
|
rooty = (0.135799 * dataxyz["head"][1] + 0.864201 * dataxyz["pelvis"][1])
|
|
rootz = (0.135799 * dataxyz["head"][2] + 0.864201 * dataxyz["pelvis"][2])
|
|
rootv = (0.135799 * dataxyz["head"][3] + 0.864201 * dataxyz["pelvis"][3])
|
|
# data["spine_02"] = makexyzrotvis(rootx, rooty, rootz, 0, 0, 0, rootv)
|
|
dataxyz["spine_02"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = (0.282213 * dataxyz["head"][0] + 0.717787 * dataxyz["pelvis"][0])
|
|
rooty = (0.282213 * dataxyz["head"][1] + 0.717787 * dataxyz["pelvis"][1])
|
|
rootz = (0.282213 * dataxyz["head"][2] + 0.717787 * dataxyz["pelvis"][2])
|
|
rootv = (0.282213 * dataxyz["head"][3] + 0.717787 * dataxyz["pelvis"][3])
|
|
data["spine_03"] = makexyzrotvis(rootx, rooty, rootz, 0, 0, 0, rootv)
|
|
dataxyz["spine_03"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = (0.451594 * dataxyz["head"][0] + 0.548406 * dataxyz["pelvis"][0])
|
|
rooty = (0.451594 * dataxyz["head"][1] + 0.548406 * dataxyz["pelvis"][1])
|
|
rootz = (0.451594 * dataxyz["head"][2] + 0.548406 * dataxyz["pelvis"][2])
|
|
rootv = (0.451594 * dataxyz["head"][3] + 0.548406 * dataxyz["pelvis"][3])
|
|
# data["spine_04"] = makexyzrotvis(rootx, rooty, rootz, 0, 0, 0, rootv)
|
|
dataxyz["spine_04"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = (0.771025 * dataxyz["head"][0] + 0.228975 * dataxyz["pelvis"][0])
|
|
rooty = (0.771025 * dataxyz["head"][1] + 0.228975 * dataxyz["pelvis"][1])
|
|
rootz = (0.771025 * dataxyz["head"][2] + 0.228975 * dataxyz["pelvis"][2])
|
|
rootv = (0.771025 * dataxyz["head"][3] + 0.228975 * dataxyz["pelvis"][3])
|
|
# data["spine_05"] = makexyzrotvis(rootx, rooty, rootz, 0, 0, 0, rootv)
|
|
dataxyz["spine_05"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = (0.635 * dataxyz["shoulder_r"][0] + 0.365 * dataxyz["shoulder_l"][0])
|
|
rooty = 0.5 * (
|
|
0.635 * dataxyz["shoulder_r"][1] + 0.365 * dataxyz["shoulder_l"][1] + 0.31 * dataxyz["head"][1] + 0.69 *
|
|
dataxyz["spine_05"][1])
|
|
rootz = (0.0635 * dataxyz["shoulder_r"][2] + 0.0365 * dataxyz["shoulder_l"][2] + 0.9 * dataxyz["spine_05"][2])
|
|
rootv = (0.635 * dataxyz["shoulder_r"][3] + 0.451594 * dataxyz["shoulder_l"][3])
|
|
dataxyz["clavicle_r"] = [rootx, rooty, rootz, rootv]
|
|
|
|
rootx = (0.635 * dataxyz["shoulder_l"][0] + 0.365 * dataxyz["shoulder_r"][0])
|
|
rooty = 0.5 * (
|
|
0.635 * dataxyz["shoulder_l"][1] + 0.365 * dataxyz["shoulder_r"][1] + 0.31 * dataxyz["head"][1] + 0.69 *
|
|
dataxyz["spine_05"][1])
|
|
rootz = (0.0635 * dataxyz["shoulder_l"][2] + 0.0365 * dataxyz["shoulder_r"][2] + 0.9 * dataxyz["spine_05"][2])
|
|
rootv = (0.635 * dataxyz["shoulder_l"][3] + 0.365 * dataxyz["shoulder_r"][3])
|
|
dataxyz["clavicle_l"] = [rootx, rooty, rootz, rootv]
|
|
|
|
|
|
boneRot("shoulder_r", "elbow_r", data, dataxyz, [-1, 0, 0], 180)
|
|
boneRot("elbow_r", "hand_r", data, dataxyz, [-1, 0, 0], 180)
|
|
boneRot("hip_r", "knee_r", data, dataxyz, [1, 0, 0], 180)
|
|
boneRot("knee_r", "ankle_r", data, dataxyz, [1, 0, 0], 180)
|
|
# boneRot("ankle_r", "ball_r", data, dataxyz, [1, 0, 0], 180)
|
|
|
|
boneRot("shoulder_l", "elbow_l", data, dataxyz, [1, 0, 0], 0)
|
|
boneRot("elbow_l", "hand_l", data, dataxyz, [1, 0, 0], 0)
|
|
boneRot("hip_l", "knee_l", data, dataxyz, [-1, 0, 0], 0)
|
|
boneRot("knee_l", "ankle_l", data, dataxyz, [-1, 0, 0], 0)
|
|
# boneRot("ankle_l", "ball_l", data, dataxyz, [-1, 0, 0], 0)
|
|
|
|
spineRot("spine_05", "pelvis", "spine_05", data, dataxyz, "shoulder_l", "shoulder_r")
|
|
spineRot("pelvis", "pelvis", "spine_05", data, dataxyz, "hip_l", "hip_r")
|
|
rvecSpine5 = [0, 0, 0]
|
|
rvecSpine5[0] = data["spine_05"]["rotation"]["rotx"]
|
|
rvecSpine5[1] = data["spine_05"]["rotation"]["roty"]
|
|
rvecSpine5[2] = data["spine_05"]["rotation"]["rotz"]
|
|
rvecPelvis = [0, 0, 0]
|
|
rvecPelvis[0] = data["pelvis"]["rotation"]["rotx"]
|
|
rvecPelvis[1] = data["pelvis"]["rotation"]["roty"]
|
|
rvecPelvis[2] = data["pelvis"]["rotation"]["rotz"]
|
|
data["spine_04"]["rotation"]["rotx"] = 0.4 * rvecSpine5[0] + 0.6 * rvecPelvis[0]
|
|
data["spine_04"]["rotation"]["roty"] = 0.4 * rvecSpine5[1] + 0.6 * rvecPelvis[1]
|
|
data["spine_04"]["rotation"]["rotz"] = 0.4 * rvecSpine5[2] + 0.6 * rvecPelvis[2]
|
|
data["spine_03"]["rotation"]["rotx"] = 0.25 * rvecSpine5[0] + 0.75 * rvecPelvis[0]
|
|
data["spine_03"]["rotation"]["roty"] = 0.25 * rvecSpine5[1] + 0.75 * rvecPelvis[1]
|
|
data["spine_03"]["rotation"]["rotz"] = 0.25 * rvecSpine5[2] + 0.75 * rvecPelvis[2]
|
|
data["spine_02"]["rotation"]["rotx"] = 0.12 * rvecSpine5[0] + 0.88 * rvecPelvis[0]
|
|
data["spine_02"]["rotation"]["roty"] = 0.12 * rvecSpine5[1] + 0.88 * rvecPelvis[1]
|
|
data["spine_02"]["rotation"]["rotz"] = 0.12 * rvecSpine5[2] + 0.88 * rvecPelvis[2]
|
|
data["spine_01"]["rotation"]["rotx"] = 0.05 * rvecSpine5[0] + 0.95 * rvecPelvis[0]
|
|
data["spine_01"]["rotation"]["roty"] = 0.05 * rvecSpine5[1] + 0.95 * rvecPelvis[1]
|
|
data["spine_01"]["rotation"]["rotz"] = 0.05 * rvecSpine5[2] + 0.95 * rvecPelvis[2]
|
|
headRot("head", "mid_shoulders", "nose", "mid_ears", "nose", data, dataxyz)
|
|
|
|
# data["shoulder_l"]["rotation"]["rotz"] = data["spine_05"]["rotation"]["rotz"] + 90
|
|
# if data["shoulder_l"]["rotation"]["rotz"] > 180:
|
|
# data["shoulder_l"]["rotation"]["rotz"] -= 180
|
|
# data["shoulder_r"]["rotation"]["rotz"] = data["spine_05"]["rotation"]["rotz"] - 90
|
|
# if data["shoulder_r"]["rotation"]["rotz"] <= -180:
|
|
# data["shoulder_r"]["rotation"]["rotz"] += 180
|
|
|