add torch smpl
This commit is contained in:
@@ -1,350 +0,0 @@
|
||||
import os
|
||||
import sys
|
||||
|
||||
import pickle
|
||||
import scipy.io as sio
|
||||
from math import *
|
||||
|
||||
import numpy as np
|
||||
import tensorflow as tf
|
||||
|
||||
# Left-Right
|
||||
eval_joints = {
|
||||
'All': [1, 2, 3, 4, 5, 7, 8, 9, 12, 15, 16, 17, 18, 19, 20, 21],
|
||||
'Head': [12, 15], # Neck, Head
|
||||
'Torso': [3, 6, 9], # Back joints
|
||||
'Shoulder': [13, 14, 16, 17], # Inner, Outer
|
||||
'Elbow': [18, 19],
|
||||
'Wrist': [20, 21],
|
||||
'Hip': [1, 2],
|
||||
'Knee': [4, 5],
|
||||
'Foot': [7, 8, 10, 11]} # Ankle, Foot
|
||||
|
||||
class SMPL:
|
||||
|
||||
def __init__(self, path):
|
||||
self.J_regressor = []
|
||||
self.v_template = []
|
||||
self.shapedirs = []
|
||||
self.posedirs = []
|
||||
self.weights = []
|
||||
# Load SMPL models
|
||||
# path = os.path.abspath(os.path.dirname(__file__))
|
||||
with open(os.path.join(path, 'super_model_f.pkl'), 'rb') as f:
|
||||
if sys.version_info[0]<3:
|
||||
female = pickle.load(f)
|
||||
else:
|
||||
female = pickle.load(f, encoding="latin1")
|
||||
self.J_regressor.append(tf.constant(np.array(female['J_regressor'].todense(), dtype=np.float32)))
|
||||
self.v_template.append(tf.constant(female['v_template'], dtype=np.float32))
|
||||
self.posedirs.append(tf.constant(female['posedirs'], dtype=np.float32))
|
||||
self.shapedirs.append(tf.constant(female['shapedirs'], dtype=np.float32))
|
||||
self.weights.append(tf.constant(female['weights'], dtype=np.float32))
|
||||
with open(os.path.join(path, 'super_model_m.pkl'), 'rb') as f:
|
||||
if sys.version_info[0]<3:
|
||||
male = pickle.load(f)
|
||||
else:
|
||||
male = pickle.load(f, encoding="latin1")
|
||||
self.J_regressor.append(tf.constant(np.array(male['J_regressor'].todense(), dtype=np.float32)))
|
||||
self.v_template.append(tf.constant(male['v_template'], dtype=np.float32))
|
||||
self.posedirs.append(tf.constant(male['posedirs'], dtype=np.float32))
|
||||
self.shapedirs.append(tf.constant(male['shapedirs'], dtype=np.float32))
|
||||
self.weights.append(tf.constant(male['weights'], dtype=np.float32))
|
||||
kintree_table = male['kintree_table']
|
||||
id_to_col = {kintree_table[1, i]: i for i in range(kintree_table.shape[1])}
|
||||
self.parent = {i: id_to_col[kintree_table[0, i]] for i in range(1, kintree_table.shape[1])}
|
||||
self.J_regressor = tf.stack(self.J_regressor, axis=0)
|
||||
self.v_template = tf.stack(self.v_template, axis=0)
|
||||
self.shapedirs = tf.stack(self.shapedirs, axis=0)
|
||||
self.posedirs = tf.stack(self.posedirs, axis=0)
|
||||
self.weights = tf.stack(self.weights, axis=0)
|
||||
self.weights_one_hot = tf.reduce_mean(self.weights, axis=0)
|
||||
self.weights_one_hot = tf.math.argmax(self.weights_one_hot, axis=-1)
|
||||
self.weights_one_hot = tf.one_hot(self.weights_one_hot, 24)
|
||||
|
||||
# Topology no head/hands/feet
|
||||
F = sio.loadmat(path + '/../Data/ssmpl_faces.mat')
|
||||
self.f = np.array(F['faces_default'])
|
||||
self.f_skirt = np.array(F['faces_skirt'])
|
||||
self.nn = np.array(sio.loadmat(path + '/../Data/NN.mat'))
|
||||
self.to_keep = sio.loadmat(os.path.join(path, 'keep_remove.mat'))['keep'].reshape(-1)
|
||||
|
||||
def Q2R(self, w, x, y, z):
|
||||
def diag(a, b): # computes the diagonal entries, 1 - 2*a**2 - 2*b**2
|
||||
return 1 - 2 * tf.pow(a, 2) - 2 * tf.pow(b, 2)
|
||||
|
||||
def tr_add(a, b, c, d): # computes triangle entries with addition
|
||||
return 2 * a * b + 2 * c * d
|
||||
|
||||
def tr_sub(a, b, c, d): # computes triangle entries with subtraction
|
||||
return 2 * a * b - 2 * c * d
|
||||
|
||||
m = [[diag(y, z), tr_sub(x, y, z, w), tr_add(x, z, y, w)],
|
||||
[tr_add(x, y, z, w), diag(x, z), tr_sub(y, z, x, w)],
|
||||
[tr_sub(x, z, y, w), tr_add(y, z, x, w), diag(x, y)]]
|
||||
|
||||
R = tf.stack([tf.stack(m[i], axis=-1) for i in range(3)], axis=-2)
|
||||
return R
|
||||
|
||||
def rodrigues(self, r):
|
||||
theta = tf.norm(r, axis=(1, 2), keepdims=True)
|
||||
theta = tf.maximum(theta, np.finfo(np.float32).eps)
|
||||
r_hat = r / theta
|
||||
z_stick = tf.zeros(theta.get_shape().as_list()[0], dtype=tf.float32)
|
||||
m = tf.stack(
|
||||
(z_stick, -r_hat[:, 0, 2], r_hat[:, 0, 1], r_hat[:, 0, 2], z_stick,
|
||||
-r_hat[:, 0, 0], -r_hat[:, 0, 1], r_hat[:, 0, 0], z_stick), axis=1)
|
||||
m = tf.reshape(m, (-1, 3, 3))
|
||||
i_cube = tf.expand_dims(tf.eye(3, dtype=tf.float32), axis=0) + tf.zeros(
|
||||
(theta.get_shape().as_list()[0], 3, 3), dtype=tf.float32)
|
||||
# R = cos * i_cube + (1 - cos) * dot + tf.sin(theta) * m
|
||||
R = i_cube + m * tf.sin(theta) + tf.matmul(m, m) * (1 - tf.cos(theta))
|
||||
return R
|
||||
|
||||
def with_zeros(self, x):
|
||||
return tf.concat((x, tf.constant([[0.0, 0.0, 0.0, 1.0]], dtype=tf.float32)), axis=0)
|
||||
|
||||
def pack(self, x):
|
||||
return tf.concat((tf.zeros((x.get_shape().as_list()[0], 4, 3), dtype=tf.float32), x), axis=2)
|
||||
|
||||
def run_rodrigues(self, pose):
|
||||
batch_size = pose.shape[0]
|
||||
R_out = self.rodrigues(tf.reshape(pose, (-1, 1, 3)))
|
||||
R_out = tf.reshape(R_out, (batch_size, -1, 3, 3))
|
||||
#R_out = []
|
||||
#for i in range(batch_size):
|
||||
# R_out.append(self.rodrigues(tf.reshape(pose[i,:], (-1, 1, 3))))
|
||||
#R_out = tf.stack(R_out, axis=0)
|
||||
return R_out
|
||||
|
||||
def run(self, R, betas, remove=True):
|
||||
batch_size = betas.shape[0]
|
||||
|
||||
#J_regressor = tf.gather(self.J_regressor, gender, axis=0)
|
||||
#shapedirs = tf.gather(self.shapedirs, gender, axis=0)
|
||||
#v_template = tf.gather(self.v_template, gender, axis=0)
|
||||
|
||||
v_shaped = []
|
||||
v_shaped.append(tf.tensordot(betas[:,:10], self.shapedirs[0], axes=[[1], [2]]) + tf.reshape(self.v_template[0], shape=(1,27578,3))) # female
|
||||
v_shaped.append(tf.tensordot(betas[:,:10], self.shapedirs[1], axes=[[1], [2]]) + tf.reshape(self.v_template[1], shape=(1,27578,3))) # male
|
||||
v_shaped = tf.stack(v_shaped, axis=-1)
|
||||
|
||||
def single_run(x, J_regressor=self.J_regressor, posedirs=self.posedirs, weights=self.weights, parent=self.parent):
|
||||
R = x[0]
|
||||
v_shaped = x[1]
|
||||
g = x[2]
|
||||
|
||||
J = tf.matmul(J_regressor[g], v_shaped[:, :, g])
|
||||
R_cube_big = R
|
||||
R_cube = R_cube_big[1:]
|
||||
I_cube = tf.expand_dims(tf.eye(3, dtype=tf.float32), axis=0) + tf.zeros((R_cube.get_shape()[0], 3, 3), dtype=tf.float32)
|
||||
lrotmin = tf.squeeze(tf.reshape((R_cube - I_cube), (-1, 1)))
|
||||
v_posed = v_shaped[:, :, g] + tf.tensordot(posedirs[g], lrotmin, axes=[[2], [0]])
|
||||
results = []
|
||||
results.append(self.with_zeros(tf.concat((R_cube_big[0], tf.reshape(J[0, :], (3, 1))), axis=1)))
|
||||
for j in range(1, 24):
|
||||
results.append(tf.matmul(results[parent[j]], self.with_zeros(tf.concat((R_cube_big[j], tf.reshape(J[j, :] - J[parent[j], :], (3, 1))), axis=1))))
|
||||
stacked = tf.stack(results, axis=0)
|
||||
results = stacked - self.pack(tf.matmul(stacked, tf.reshape(tf.concat((J, tf.zeros((24, 1), dtype=tf.float32)), axis=1), (24, 4, 1))))
|
||||
|
||||
J = tf.matmul(results, tf.expand_dims(tf.concat([J, tf.ones([24, 1], tf.float32)], axis=1), axis=1), transpose_b=True)
|
||||
J = tf.gather(J, tf.constant([0, 1, 2], tf.int32), axis=1)
|
||||
|
||||
T = tf.tensordot(weights[g], results, axes=((1), (0)))
|
||||
rest_shape_h = tf.concat((v_posed, tf.ones((v_posed.get_shape().as_list()[0], 1), dtype=tf.float32)), axis=1)
|
||||
v = tf.matmul(T, tf.reshape(rest_shape_h, (-1, 4, 1)))
|
||||
v = tf.reshape(v, (-1, 4))[:, :3]
|
||||
|
||||
return v, tf.squeeze(J), v_posed
|
||||
|
||||
gender = tf.cast(tf.greater_equal(betas[:, 10] , 0), tf.int32)
|
||||
T_out, J_out, v_posed = tf.map_fn(single_run, (R, v_shaped, gender), (tf.float32, tf.float32, tf.float32))
|
||||
|
||||
J0 = tf.reshape(J_out[:,0,:], (-1, 1, 3))
|
||||
J_out = tf.subtract(J_out, J0)
|
||||
T_out = tf.subtract(T_out, J0)
|
||||
v_posed = tf.subtract(v_posed, J0)
|
||||
|
||||
if remove:
|
||||
T_out = tf.gather(T_out, self.to_keep, axis=1)
|
||||
v_posed = tf.gather(v_posed, self.to_keep, axis=1)
|
||||
|
||||
return T_out, J_out, v_posed
|
||||
|
||||
def run_with_weights(self, R, betas, v_cloth, weights=None, filter=None):
|
||||
|
||||
v_shaped = []
|
||||
v_shaped.append(tf.tensordot(betas[:,:10], self.shapedirs[0], axes=[[1], [2]]) + tf.reshape(self.v_template[0], shape=(1,27578,3))) # female
|
||||
v_shaped.append(tf.tensordot(betas[:,:10], self.shapedirs[1], axes=[[1], [2]]) + tf.reshape(self.v_template[1], shape=(1,27578,3))) # male
|
||||
v_shaped = tf.stack(v_shaped, axis=-1)
|
||||
|
||||
if weights is None:
|
||||
w = self.weights_one_hot[np.newaxis, :, :]
|
||||
if filter is not None:
|
||||
w = tf.gather(tf.gather(w, self.to_keep, axis=1), filter, axis=1)
|
||||
if v_cloth.shape[1] == 14475:
|
||||
w = tf.gather(w, self.to_keep, axis=1)
|
||||
else:
|
||||
w = weights
|
||||
|
||||
def single_run(x, J_regressor=self.J_regressor, w=w, parent=self.parent):
|
||||
R = x[0]
|
||||
v_shaped = x[1]
|
||||
g = x[2]
|
||||
v_cloth = x[3]
|
||||
|
||||
J = tf.matmul(J_regressor[g], v_shaped[:, :, g])
|
||||
R_cube_big = R
|
||||
results = []
|
||||
results.append(self.with_zeros(tf.concat((R_cube_big[0], tf.reshape(J[0, :], (3, 1))), axis=1)))
|
||||
for j in range(1, 24):
|
||||
results.append(tf.matmul(results[parent[j]], self.with_zeros(tf.concat((R_cube_big[j], tf.reshape(J[j, :] - J[parent[j], :], (3, 1))), axis=1))))
|
||||
stacked = tf.stack(results, axis=0)
|
||||
results = stacked - self.pack(tf.matmul(stacked, tf.reshape(tf.concat((J, tf.zeros((24, 1), dtype=tf.float32)), axis=1), (24, 4, 1))))
|
||||
|
||||
J = tf.matmul(results, tf.expand_dims(tf.concat([J, tf.ones([24, 1], tf.float32)], axis=1), axis=1), transpose_b=True)
|
||||
J = tf.gather(J, tf.constant([0, 1, 2], tf.int32), axis=1)
|
||||
|
||||
T = tf.tensordot(w[0], results, axes=((1), (0)))
|
||||
rest_shape_h = tf.concat((v_cloth, tf.ones((v_cloth.shape[0], 1), dtype=tf.float32)), axis=1)
|
||||
v = tf.matmul(T, tf.reshape(rest_shape_h, (-1, 4, 1)))
|
||||
v = tf.reshape(v, (-1, 4))[:, :3]
|
||||
|
||||
return v, tf.squeeze(J)
|
||||
|
||||
gender = tf.cast(tf.greater_equal(betas[:, 10] , 0), tf.int32)
|
||||
T_out, J_out = tf.map_fn(single_run, (R, v_shaped, gender, v_cloth), (tf.float32, tf.float32))
|
||||
|
||||
J0 = tf.reshape(J_out[:,0,:], (-1, 1, 3))
|
||||
T_out = tf.subtract(T_out, J0)
|
||||
|
||||
return T_out
|
||||
|
||||
def get_joints_template(self, betas):
|
||||
v_shaped = []
|
||||
v_shaped.append(tf.tensordot(betas[:,:10], self.shapedirs[0], axes=[[1], [2]]) + tf.reshape(self.v_template[0], shape=(1,27578,3))) # female
|
||||
v_shaped.append(tf.tensordot(betas[:,:10], self.shapedirs[1], axes=[[1], [2]]) + tf.reshape(self.v_template[1], shape=(1,27578,3))) # male
|
||||
v_shaped = tf.stack(v_shaped, axis=-1)
|
||||
|
||||
def single_run(x, J_regressor=self.J_regressor):
|
||||
v_shaped = x[0]
|
||||
g = x[1]
|
||||
J = tf.matmul(J_regressor[g], v_shaped[:, :, g])
|
||||
return J
|
||||
|
||||
gender = tf.cast(tf.greater_equal(betas[:, 10] , 0), tf.int32)
|
||||
J = tf.map_fn(single_run, (v_shaped, gender), (tf.float32))
|
||||
J0 = tf.reshape(J[:,0,:], (-1, 1, 3))
|
||||
|
||||
return tf.subtract(J, J0)
|
||||
|
||||
|
||||
def run_garment(self, R, betas, v_cloth, J=None, fl_idx=None):
|
||||
if J is None:
|
||||
J = self.get_joints_template(betas)
|
||||
|
||||
weights = tf.gather(self.weights, self.to_keep, axis=1)
|
||||
|
||||
if fl_idx is not None:
|
||||
weights = tf.gather(weights, fl_idx, axis=1)
|
||||
|
||||
def single_run(x, J_regressor=self.J_regressor, posedirs=self.posedirs, weights=weights, parent=self.parent):
|
||||
R = x[0]
|
||||
J = x[1]
|
||||
g = x[2]
|
||||
v_cloth = x[3]
|
||||
|
||||
R_cube_big = R
|
||||
# R_cube = R_cube_big[1:]
|
||||
# I_cube = tf.expand_dims(tf.eye(3, dtype=tf.float32), axis=0) + tf.zeros((R_cube.get_shape()[0], 3, 3), dtype=tf.float32)
|
||||
# lrotmin = tf.squeeze(tf.reshape((R_cube - I_cube), (-1, 1)))
|
||||
|
||||
results = []
|
||||
results.append(self.with_zeros(tf.concat((R_cube_big[0], tf.reshape(J[0, :], (3, 1))), axis=1)))
|
||||
for j in range(1, 24):
|
||||
results.append(tf.matmul(results[parent[j]], self.with_zeros(tf.concat((R_cube_big[j], tf.reshape(J[j, :] - J[parent[j], :], (3, 1))), axis=1))))
|
||||
stacked = tf.stack(results, axis=0)
|
||||
results = stacked - self.pack(tf.matmul(stacked, tf.reshape(tf.concat((J, tf.zeros((24, 1), dtype=tf.float32)), axis=1), (24, 4, 1))))
|
||||
|
||||
J = tf.matmul(results, tf.expand_dims(tf.concat([J, tf.ones([24, 1], tf.float32)], axis=1), axis=1), transpose_b=True)
|
||||
J = tf.gather(J, tf.constant([0, 1, 2], tf.int32), axis=1)
|
||||
|
||||
T = tf.tensordot(weights[g, :, :], results, axes=((1), (0)))
|
||||
rest_shape_h = tf.concat((v_cloth, tf.ones((v_cloth.shape[0], 1), dtype=tf.float32)), axis=1)
|
||||
v = tf.matmul(T, tf.reshape(rest_shape_h, (-1, 4, 1)))
|
||||
v = tf.reshape(v, (-1, 4))[:, :3]
|
||||
|
||||
return v, tf.squeeze(J)
|
||||
|
||||
gender = tf.cast(tf.greater_equal(betas[:, 10] , 0), tf.int32)
|
||||
T_out, J_out = tf.map_fn(single_run, (R, J, gender, v_cloth), (tf.float32, tf.float32))
|
||||
|
||||
J0 = tf.reshape(J_out[:,0,:], (-1, 1, 3))
|
||||
J_out = tf.subtract(J_out, J0)
|
||||
T_out = tf.subtract(T_out, J0)
|
||||
|
||||
return T_out
|
||||
|
||||
def run_garment_with_weights(self, R, betas, v_cloth, weights, J=None):
|
||||
|
||||
if J is None:
|
||||
J = self.get_joints_template(betas)
|
||||
|
||||
def single_run(x, parent=self.parent):
|
||||
R = x[0]
|
||||
J = x[1]
|
||||
v_cloth = x[2]
|
||||
weights = x[3]
|
||||
|
||||
R_cube_big = R
|
||||
|
||||
results = []
|
||||
results.append(self.with_zeros(tf.concat((R_cube_big[0], tf.reshape(J[0, :], (3, 1))), axis=1)))
|
||||
for j in range(1, 24):
|
||||
results.append(tf.matmul(results[parent[j]], self.with_zeros(tf.concat((R_cube_big[j], tf.reshape(J[j, :] - J[parent[j], :], (3, 1))), axis=1))))
|
||||
stacked = tf.stack(results, axis=0)
|
||||
results = stacked - self.pack(tf.matmul(stacked, tf.reshape(tf.concat((J, tf.zeros((24, 1), dtype=tf.float32)), axis=1), (24, 4, 1))))
|
||||
|
||||
J = tf.matmul(results, tf.expand_dims(tf.concat([J, tf.ones([24, 1], tf.float32)], axis=1), axis=1), transpose_b=True)
|
||||
J = tf.gather(J, tf.constant([0, 1, 2], tf.int32), axis=1)
|
||||
|
||||
T = tf.tensordot(weights, results, axes=((1), (0)))
|
||||
rest_shape_h = tf.concat((v_cloth, tf.ones((v_cloth.get_shape().as_list()[0], 1), dtype=tf.float32)), axis=1)
|
||||
v = tf.matmul(T, tf.reshape(rest_shape_h, (-1, 4, 1)))
|
||||
v = tf.reshape(v, (-1, 4))[:, :3]
|
||||
|
||||
return v, tf.squeeze(J)
|
||||
|
||||
# gender = tf.cast(tf.greater_equal(betas[:, 10] , 0), tf.int32)
|
||||
T_out, J_out = tf.map_fn(single_run, (R, J, v_cloth, weights), (tf.float32, tf.float32))
|
||||
|
||||
J0 = tf.reshape(J_out[:,0,:], (-1, 1, 3))
|
||||
J_out = tf.subtract(J_out, J0)
|
||||
T_out = tf.subtract(T_out, J0)
|
||||
|
||||
return T_out
|
||||
|
||||
def run_backward(self, R, J, v_posed, weights):
|
||||
batch_size = R.get_shape()[0]
|
||||
|
||||
J_relative = J[:, 1:, :] - tf.gather(J, tf.constant(list(self.parent.values()), tf.int32), axis=1) # batch_size x 23 x 3
|
||||
|
||||
J_out = []
|
||||
J_out.append(tf.expand_dims(J[:, 0, :], axis=-1)) # batch_size x 3 x 1
|
||||
results = []
|
||||
results.append(tf.expand_dims(tf.eye(3, dtype=tf.float32), axis=0) + tf.zeros((batch_size, 3, 3), dtype=tf.float32))
|
||||
for j in range(1, 24):
|
||||
results.append(tf.matmul(R[:, self.parent[j], :, :], results[self.parent[j]]))
|
||||
J_out.append(tf.matmul(results[j], tf.expand_dims(J_relative[:, j-1, :], axis=-1)) + J_out[self.parent[j]]) # batch_size x 3 x 1
|
||||
results = tf.transpose(tf.stack(results, axis=0), [1, 0, 2, 3]) # (batch_size x 24 x 3 x 3)
|
||||
J_out = tf.transpose(tf.stack(J_out, axis=0), [1, 0, 2, 3]) # (batch_size x 24 x 3 x 1)
|
||||
|
||||
results = tf.matmul(R, results)
|
||||
T = tf.transpose(tf.tensordot(results, weights, axes=((1), (1))), [0, 3, 1, 2]) # (batch_size x 6890 x 3 x 3)
|
||||
v_posed = tf.expand_dims(v_posed, axis=-1) # (batch_size x 6890 x 3 x 1)
|
||||
J = tf.expand_dims(J, axis=-1) # (batch_size x 24 x 3 x 1)
|
||||
v = tf.matmul(T, v_posed) + tf.transpose(tf.tensordot(J_out - tf.matmul(results, J), weights, axes=((1), (1))), [0, 3, 1, 2]) # (batch_size x 6890 x 3 x 1)
|
||||
v = tf.squeeze(v, -1) # (batch_size x 6890 x 3)
|
||||
J_out = tf.squeeze(J_out, -1) # (batch_size x 24 x 3)
|
||||
|
||||
return v, J_out
|
||||
Executable
+224
@@ -0,0 +1,224 @@
|
||||
# based on https://github.com/CalciferZh/SMPL/blob/master/smpl_torch_batch.py
|
||||
|
||||
import os
|
||||
import sys
|
||||
import pickle
|
||||
import torch
|
||||
import numpy as np
|
||||
import scipy.io as sio
|
||||
from time import time
|
||||
from torch.nn import Module
|
||||
|
||||
class SMPL(Module):
|
||||
def __init__(self, device=None, path='', orig_smpl=False, is_skirt=False):
|
||||
|
||||
super(SMPL, self).__init__()
|
||||
self.J_regressor = []
|
||||
self.v_template = []
|
||||
self.shapedirs = []
|
||||
self.posedirs = []
|
||||
self.weights = []
|
||||
self.is_skirt = is_skirt
|
||||
# Load SMPL models
|
||||
# path = os.path.abspath(os.path.dirname(__file__))
|
||||
with open(os.path.join(path, 'super_model_f.pkl'), 'rb') as f:
|
||||
female = pickle.load(f, encoding="latin1")
|
||||
self.J_regressor.append(torch.tensor(np.array(female['J_regressor'].todense(), dtype=np.float32)))
|
||||
self.v_template.append(torch.tensor(female['v_template'], dtype=torch.float32))
|
||||
self.posedirs.append(torch.tensor(female['posedirs'], dtype=torch.float32))
|
||||
self.shapedirs.append(torch.tensor(female['shapedirs'], dtype=torch.float32))
|
||||
self.weights.append(torch.tensor(female['weights'], dtype=torch.float32))
|
||||
with open(os.path.join(path, 'super_model_m.pkl'), 'rb') as f:
|
||||
male = pickle.load(f, encoding="latin1")
|
||||
self.J_regressor.append(torch.tensor(np.array(male['J_regressor'].todense(), dtype=np.float32)))
|
||||
self.v_template.append(torch.tensor(male['v_template'], dtype=torch.float32))
|
||||
self.posedirs.append(torch.tensor(male['posedirs'], dtype=torch.float32))
|
||||
self.shapedirs.append(torch.tensor(male['shapedirs'], dtype=torch.float32))
|
||||
self.weights.append(torch.tensor(male['weights'], dtype=torch.float32))
|
||||
kintree_table = male['kintree_table']
|
||||
id_to_col = {kintree_table[1, i]: i for i in range(kintree_table.shape[1])}
|
||||
self.parent = {i: id_to_col[kintree_table[0, i]] for i in range(1, kintree_table.shape[1])}
|
||||
self.J_regressor = torch.stack(self.J_regressor, axis=0).to(device)
|
||||
self.v_template = torch.stack(self.v_template, axis=0).to(device)
|
||||
self.shapedirs = torch.stack(self.shapedirs, axis=0).to(device)
|
||||
self.posedirs = torch.stack(self.posedirs, axis=0).to(device)
|
||||
self.weights = torch.stack(self.weights, axis=0).to(device)
|
||||
|
||||
# Topology no head/hands/feet
|
||||
F = sio.loadmat(os.path.join(path, 'ssmpl_faces.mat'))
|
||||
self.f = np.array(F['faces_default'])
|
||||
self.f_skirt = np.array(F['faces_skirt'])
|
||||
self.nn = np.array(sio.loadmat(os.path.join(path, 'NN.mat')))
|
||||
self.to_keep = sio.loadmat(os.path.join(path, 'keep_remove.mat'))['keep'].reshape(-1)
|
||||
|
||||
self.weights_all = self.weights
|
||||
self.weights = self.weights[:,self.to_keep,:]
|
||||
|
||||
self.shape = (1,27578,3)
|
||||
self.device = device
|
||||
|
||||
if orig_smpl:
|
||||
self.to_keep = self.to_keep[self.to_keep < 6890]
|
||||
self.J_regressor = self.J_regressor[:,:,:6890]
|
||||
self.v_template = self.v_template[:,:6890,:]
|
||||
self.shapedirs = self.shapedirs[:,:6890,:,:]
|
||||
self.posedirs = self.posedirs[:,:6890,:,:]
|
||||
self.weights_all = self.weights_all[:,:6890,:]
|
||||
self.weights = self.weights_all[:,self.to_keep,:]
|
||||
self.shape = (1, 6890, 3)
|
||||
|
||||
@staticmethod
|
||||
def rodrigues(r):
|
||||
"""
|
||||
Rodrigues' rotation formula that turns axis-angle tensor into rotation
|
||||
matrix in a batch-ed manner.
|
||||
Parameter:
|
||||
----------
|
||||
r: Axis-angle rotation tensor of shape [batch_size * angle_num, 1, 3].
|
||||
Return:
|
||||
-------
|
||||
Rotation matrix of shape [batch_size * angle_num, 3, 3].
|
||||
"""
|
||||
# eps = r.clone().normal_(std=1e-8)
|
||||
# theta = torch.norm(r + eps, dim=(1, 2), keepdim=True) # dim cannot be tuple
|
||||
theta = torch.norm(r, dim=(1, 2), keepdim=True)
|
||||
theta = torch.maximum(theta, torch.ones_like(theta) * np.finfo(np.float32).eps)
|
||||
|
||||
theta_dim = theta.shape[0]
|
||||
r_hat = r / theta
|
||||
# cos = torch.cos(theta)
|
||||
z_stick = torch.zeros(theta_dim, dtype=torch.float32).to(r.device)
|
||||
m = torch.stack(
|
||||
(z_stick, -r_hat[:, 0, 2], r_hat[:, 0, 1], r_hat[:, 0, 2], z_stick,
|
||||
-r_hat[:, 0, 0], -r_hat[:, 0, 1], r_hat[:, 0, 0], z_stick), dim=1)
|
||||
m = torch.reshape(m, (-1, 3, 3))
|
||||
i_cube = (torch.eye(3, dtype=torch.float32).unsqueeze(dim=0) \
|
||||
+ torch.zeros((theta_dim, 3, 3), dtype=torch.float32)).to(r.device)
|
||||
A = r_hat.permute(0, 2, 1)
|
||||
# dot = torch.matmul(A, r_hat)
|
||||
# R = cos * i_cube + (1 - cos) * dot + torch.sin(theta) * m
|
||||
R = i_cube + m * torch.sin(theta) + torch.matmul(m, m) * (1 - torch.cos(theta))
|
||||
return R
|
||||
|
||||
@staticmethod
|
||||
def with_zeros(x):
|
||||
"""
|
||||
Append a [0, 0, 0, 1] tensor to a [3, 4] tensor.
|
||||
Parameter:
|
||||
---------
|
||||
x: Tensor to be appended.
|
||||
Return:
|
||||
------
|
||||
Tensor after appending of shape [4,4]
|
||||
"""
|
||||
ones = torch.tensor(
|
||||
[[[0.0, 0.0, 0.0, 1.0]]], dtype=torch.float32
|
||||
).expand(x.shape[0],-1,-1).to(x.device)
|
||||
ret = torch.cat((x, ones), dim=1)
|
||||
return ret
|
||||
|
||||
@staticmethod
|
||||
def pack(x):
|
||||
"""
|
||||
Append zero tensors of shape [4, 3] to a batch of [4, 1] shape tensor.
|
||||
Parameter:
|
||||
----------
|
||||
x: A tensor of shape [batch_size, 4, 1]
|
||||
Return:
|
||||
------
|
||||
A tensor of shape [batch_size, 4, 4] after appending.
|
||||
"""
|
||||
zeros43 = torch.zeros(
|
||||
(x.shape[0], x.shape[1], 4, 3), dtype=torch.float32).to(x.device)
|
||||
ret = torch.cat((zeros43, x), dim=3)
|
||||
return ret
|
||||
|
||||
|
||||
def forward(self, pose, betas, verts: torch.Tensor = None, remove: bool = True):
|
||||
|
||||
"""
|
||||
Construct a compute graph that takes in parameters and outputs a tensor as
|
||||
model vertices. Face indices are also returned as a numpy ndarray.
|
||||
|
||||
20190128: Add batch support.
|
||||
Parameters:
|
||||
---------
|
||||
pose: Also known as 'theta', an [N, 24, 3] tensor indicating child joint rotation
|
||||
relative to parent joint. For root joint it's global orientation.
|
||||
Represented in a axis-angle format.
|
||||
betas: Parameter for model shape. A tensor of shape [N, 10] as coefficients of
|
||||
PCA components. Only 10 components were released by SMPL author.
|
||||
trans: Global translation tensor of shape [N, 3].
|
||||
Return:
|
||||
------
|
||||
A 3-D tensor of [N * 6890 * 3] for vertices,
|
||||
and the corresponding [N * 19 * 3] joint positions.
|
||||
"""
|
||||
batch_num = betas.shape[0]
|
||||
|
||||
# v_shaped = torch.tensordot(betas, self.shapedirs, dims=([1], [2])) + self.v_template
|
||||
v_shaped = []
|
||||
v_shaped.append(torch.tensordot(betas[:,:10], self.shapedirs[0], dims=[[1], [2]]) + torch.reshape(self.v_template[0], shape=self.shape)) # female
|
||||
v_shaped.append(torch.tensordot(betas[:,:10], self.shapedirs[1], dims=[[1], [2]]) + torch.reshape(self.v_template[1], shape=self.shape)) # male
|
||||
v_shaped = torch.stack(v_shaped, axis=-1)
|
||||
|
||||
# J = torch.matmul(self.J_regressor, v_shaped)
|
||||
J = torch.stack([torch.matmul(self.J_regressor[g.to(torch.long)], v_shaped[i, :, :, g.to(torch.long)]) for i, g in enumerate(betas[:,-1])])
|
||||
R_cube_big = self.rodrigues(pose.reshape(-1, 1, 3)).reshape(batch_num, -1, 3, 3)
|
||||
|
||||
if verts is not None:
|
||||
v_posed = verts
|
||||
else:
|
||||
R_cube = R_cube_big[:, 1:, :, :]
|
||||
I_cube = (torch.eye(3, dtype=torch.float32).unsqueeze(dim=0) + \
|
||||
torch.zeros((batch_num, R_cube.shape[1], 3, 3), dtype=torch.float32)).to(self.device)
|
||||
lrotmin = (R_cube - I_cube).reshape(batch_num, -1, 1).squeeze(dim=2)
|
||||
v_posed = torch.stack([v_shaped[i, :, :, g.to(torch.long)] + torch.tensordot(lrotmin[i], self.posedirs[g.to(torch.long)], dims=([0], [2])) for i, g in enumerate(betas[:,-1])])
|
||||
|
||||
results = []
|
||||
results.append(
|
||||
self.with_zeros(torch.cat((R_cube_big[:, 0], torch.reshape(J[:, 0, :], (-1, 3, 1))), dim=2))
|
||||
)
|
||||
for i in range(1, 24):
|
||||
results.append(
|
||||
torch.matmul(
|
||||
results[self.parent[i]],
|
||||
self.with_zeros(
|
||||
torch.cat(
|
||||
(R_cube_big[:, i], torch.reshape(J[:, i, :] - J[:, self.parent[i], :], (-1, 3, 1))),
|
||||
dim=2
|
||||
)
|
||||
)
|
||||
)
|
||||
)
|
||||
|
||||
stacked = torch.stack(results, dim=1)
|
||||
results = stacked - \
|
||||
self.pack(
|
||||
torch.matmul(
|
||||
stacked,
|
||||
torch.reshape(
|
||||
torch.cat((J, torch.zeros((batch_num, 24, 1), dtype=torch.float32).to(self.device)), dim=2),
|
||||
(batch_num, 24, 4, 1)
|
||||
)
|
||||
)
|
||||
)
|
||||
|
||||
joints = torch.matmul(results, torch.transpose(torch.concat([J, torch.ones((J.shape[0], 24, 1), dtype=torch.float32, device=J.get_device())], axis=-1)[:,:,None,:],2,3))[:,:,:3,0]
|
||||
|
||||
T = torch.stack([torch.tensordot(results[i], self.weights[g.to(torch.long)], dims=([0], [1])).permute(2, 0, 1) for i, g in enumerate(betas[:,-1])])
|
||||
rest_shape_h = torch.cat(
|
||||
(v_posed, torch.ones((batch_num, v_posed.shape[1], 1), dtype=torch.float32).to(self.device)), dim=2
|
||||
)
|
||||
v = torch.matmul(T, torch.reshape(rest_shape_h, (batch_num, -1, 4, 1)))
|
||||
v = torch.reshape(v, (batch_num, -1, 4))[:, :, :3]
|
||||
result = v
|
||||
|
||||
root_joint = torch.reshape(joints[:,0,:], (-1, 1, 3))
|
||||
result = result - root_joint
|
||||
joints = joints - root_joint
|
||||
|
||||
if remove and verts is None:
|
||||
result = result[:,self.to_keep,:]
|
||||
|
||||
return result, joints
|
||||
Reference in New Issue
Block a user