def __init__(self, args, joint_topology, origin_offsets: torch.Tensor,
device, characters):
self.args = args
self.joint_topology = joint_topology
self.edges = build_edge_topology(joint_topology,
torch.zeros((len(joint_topology), 3)))
self.fk = ForwardKinematics(args, self.edges)
self.height = [] # for normalize ee_loss
self.real_height = []
for char in characters:
if args.use_sep_ee:
h = BVH_file(get_std_bvh(dataset=char)).get_ee_length()
else:
h = BVH_file(get_std_bvh(dataset=char)).get_height()
if args.ee_loss_fact == 'learn':
h = torch.tensor(h, dtype=torch.float)
else:
h = torch.tensor(h, dtype=torch.float, requires_grad=False)
self.real_height.append(
BVH_file(get_std_bvh(dataset=char)).get_height())
self.height.append(h.unsqueeze(0))
self.real_height = torch.tensor(self.real_height, device=device)
self.height = torch.cat(self.height, dim=0)
self.height = self.height.to(device)
if not args.use_sep_ee: self.height.unsqueeze_(-1)
if args.ee_loss_fact == 'learn': self.height_para = [self.height]
else: self.height_para = []
if not args.simple_operator:
self.auto_encoder = AE(args, topology=self.edges).to(device)
self.discriminator = Discriminator(args, self.edges).to(device)
self.static_encoder = StaticEncoder(args, self.edges).to(device)
else:
raise Exception('Conventional operator not yet implemented')
def __init__(self, args, character_names, dataset):
super(GAN_model, self).__init__(args)
self.character_names = character_names
self.dataset = dataset
self.n_topology = len(character_names)
self.models = []
self.D_para = []
self.G_para = []
self.args = args
for i in range(self.n_topology):
model = IntegratedModel(args, dataset.joint_topologies[i], None,
self.device, character_names[i])
self.models.append(model)
self.D_para += model.D_parameters()
self.G_para += model.G_parameters()
if self.is_train:
self.fake_pools = []
self.optimizerD = optim.Adam(self.D_para,
args.learning_rate,
betas=(0.9, 0.999))
self.optimizerG = optim.Adam(self.G_para,
args.learning_rate,
betas=(0.9, 0.999))
self.optimizers = [self.optimizerD, self.optimizerG]
self.criterion_rec = torch.nn.MSELoss()
self.criterion_gan = GAN_loss(args.gan_mode).to(self.device)
self.criterion_cycle = torch.nn.L1Loss()
self.criterion_ee = Criterion_EE(args, torch.nn.MSELoss())
for i in range(self.n_topology):
self.fake_pools.append(ImagePool(args.pool_size))
else:
import option_parser
self.err_crit = []
for i in range(self.n_topology):
self.err_crit.append(
Eval_Criterion(dataset.joint_topologies[i]))
self.id_test = 0
self.bvh_path = os.path.join(args.save_dir, 'results/bvh')
option_parser.try_mkdir(self.bvh_path)
self.writer = []
for i in range(self.n_topology):
writer_group = []
for _, char in enumerate(character_names[i]):
from datasets.bvh_writer import BVH_writer
from datasets.bvh_parser import BVH_file
import option_parser
file = BVH_file(option_parser.get_std_bvh(dataset=char))
writer_group.append(BVH_writer(file.edges, file.names))
self.writer.append(writer_group)
def __init__(self, args, datasets_groups, device=None):
if device is None:
device = torch.device(args.cuda_device if (
torch.cuda.is_available()) else 'cpu')
self.final_data = []
self.length = 0
self.offsets = []
self.joint_topologies = []
self.ee_ids = []
self.means = []
self.vars = []
dataset_num = 0
total_length = 100000
all_datas = []
for datasets in datasets_groups:
offsets_group = []
means_group = []
vars_group = []
dataset_num += len(datasets)
tmp = []
for i, dataset in enumerate(datasets):
new_args = copy.copy(args)
new_args.data_augment = 0
new_args.dataset = dataset
tmp.append(MotionData(new_args))
means_group.append(tmp[-1].mean)
vars_group.append(tmp[-1].var)
file = BVH_file(get_std_bvh(dataset=dataset))
if i == 0:
self.joint_topologies.append(file.topology)
self.ee_ids.append(file.get_ee_id())
new_offset = file.offset
new_offset = torch.tensor(new_offset, dtype=torch.float)
new_offset = new_offset.reshape((1, ) + new_offset.shape)
offsets_group.append(new_offset)
total_length = min(total_length, len(tmp[-1]))
all_datas.append(tmp[0]) # tmp[0] means only support one ske
offsets_group = torch.cat(offsets_group, dim=0)
offsets_group = offsets_group.to(device)
means_group = torch.cat(means_group, dim=0).to(device)
vars_group = torch.cat(vars_group, dim=0).to(device)
self.offsets.append(offsets_group)
self.means.append(means_group)
self.vars.append(vars_group)
self.all_data = all_datas
self.length = total_length
def batch(char, suffix):
input_path = './pretrained/results/bvh'
all_err = []
ref_file = get_std_bvh(dataset=char)
ref_file = BVH_file(ref_file)
height = ref_file.get_height()
test_num = 0
new_p = os.path.join(input_path, char)
files = [
f for f in os.listdir(new_p)
if f.endswith('_{}.bvh'.format(suffix)) and not f.endswith('_gt.bvh')
and 'fix' not in f and not f.endswith('_input.bvh')
]
for file in files:
file_full = os.path.join(new_p, file)
anim, names, _ = BVH.load(file_full)
test_num += 1
index = []
for i, name in enumerate(names):
if 'virtual' in name:
continue
index.append(i)
file_ref = file_full[:-6] + '_gt.bvh'
anim_ref, _, _ = BVH.load(file_ref)
pos = Animation.positions_global(anim) # [T, J, 3]
pos_ref = Animation.positions_global(anim_ref)
pos = pos[:, index, :]
pos_ref = pos_ref[:, index, :]
err = (pos - pos_ref) * (pos - pos_ref)
err /= height**2
err = np.mean(err)
all_err.append(err)
all_err = np.array(all_err)
return all_err.mean()
def __init__(self, args):
super(MotionData, self).__init__()
name = args.dataset
file_path = './datasets/Mixamo/{}.npy'.format(name)
if args.debug:
file_path = file_path[:-4] + '_debug' + file_path[-4:]
print('load from file {}'.format(file_path))
self.total_frame = 0
self.std_bvh = get_std_bvh(args)
self.args = args
self.data = []
self.motion_length = []
motions = np.load(file_path, allow_pickle=True)
motions = list(motions)
new_windows = self.get_windows(motions)
self.data.append(new_windows)
self.data = torch.cat(self.data)
self.data = self.data.permute(0, 2, 1)
if args.normalization == 1:
self.mean = torch.mean(self.data, (0, 2), keepdim=True)
self.var = torch.var(self.data, (0, 2), keepdim=True)
self.var = self.var**(1 / 2)
idx = self.var < 1e-5
self.var[idx] = 1
self.data = (self.data - self.mean) / self.var
else:
self.mean = torch.mean(self.data, (0, 2), keepdim=True)
self.mean.zero_()
self.var = torch.ones_like(self.mean)
train_len = self.data.shape[0] * 95 // 100
self.test_set = self.data[train_len:, ...]
self.data = self.data[:train_len, ...]
self.data_reverse = torch.tensor(self.data.numpy()[..., ::-1].copy())
self.reset_length_flag = 0
self.virtual_length = 0
print(
'Window count: {}, total frame (without downsampling): {}'.format(
len(self), self.total_frame))
def __init__(self, args, characters):
self.characters = characters
self.file_list = get_test_set()
self.mean = []
self.joint_topologies = []
self.var = []
self.offsets = []
self.ee_ids = []
self.args = args
self.device = torch.device(args.cuda_device)
for i, character_group in enumerate(characters):
mean_group = []
var_group = []
offsets_group = []
for j, character in enumerate(character_group):
file = BVH_file(get_std_bvh(dataset=character))
if j == 0:
self.joint_topologies.append(file.topology)
self.ee_ids.append(file.get_ee_id())
new_offset = file.offset
new_offset = torch.tensor(new_offset, dtype=torch.float)
new_offset = new_offset.reshape((1, ) + new_offset.shape)
offsets_group.append(new_offset)
mean = np.load(
'./datasets/Mixamo/mean_var/{}_mean.npy'.format(character))
var = np.load(
'./datasets/Mixamo/mean_var/{}_var.npy'.format(character))
mean = torch.tensor(mean)
mean = mean.reshape((1, ) + mean.shape)
var = torch.tensor(var)
var = var.reshape((1, ) + var.shape)
mean_group.append(mean)
var_group.append(var)
mean_group = torch.cat(mean_group, dim=0).to(self.device)
var_group = torch.cat(var_group, dim=0).to(self.device)
offsets_group = torch.cat(offsets_group, dim=0).to(self.device)
self.mean.append(mean_group)
self.var.append(var_group)
self.offsets.append(offsets_group)
def __init__(self, file_path=None, args=None, dataset=None, new_root=None):
if file_path is None:
file_path = get_std_bvh(dataset=dataset)
self.anim, self._names, self.frametime = BVH.load(file_path)
if new_root is not None:
self.set_new_root(new_root)
self.skeleton_type = -1
self.edges = []
self.edge_mat = []
self.edge_num = 0
self._topology = None
self.ee_length = []
for i, name in enumerate(self._names):
if ':' in name:
name = name[name.find(':') + 1:]
self._names[i] = name
full_fill = [1] * len(corps_names)
for i, ref_names in enumerate(corps_names):
for ref_name in ref_names:
if ref_name not in self._names:
full_fill[i] = 0
break
if full_fill[3]:
self.skeleton_type = 3
else:
for i, _ in enumerate(full_fill):
if full_fill[i]:
self.skeleton_type = i
break
if self.skeleton_type == 2 and full_fill[4]:
self.skeleton_type = 4
if 'Neck1' in self._names:
self.skeleton_type = 5
if 'Left_End' in self._names:
self.skeleton_type = 6
if 'Three_Arms_Hips' in self._names:
self.skeleton_type = 7
if 'Three_Arms_Hips_split' in self._names:
self.skeleton_type = 8
if 'LHipJoint' in self._names:
self.skeleton_type = 3
if 'HipsPrisoner' in self._names:
self.skeleton_type = 9
if 'Spine1_split' in self._names:
self.skeleton_type = 10
"""
4.
Here, you need to assign self.skeleton_type the corresponding index of your own dataset in corps_names or ee_names list.
You can use self._names, which contains the joints name in original bvh file, to write your own if statement.
"""
# if ...:
# self.skeleton_type = 11
if self.skeleton_type == -1:
print(self._names)
raise Exception('Unknown skeleton')
if self.skeleton_type == 0:
self.set_new_root(1)
self.details = []
for i, name in enumerate(self._names):
if ':' in name: name = name[name.find(':') + 1:]
if name not in corps_names[self.skeleton_type]:
self.details.append(i)
self.joint_num = self.anim.shape[1]
self.corps = []
self.simplified_name = []
self.simplify_map = {}
self.inverse_simplify_map = {}
for name in corps_names[self.skeleton_type]:
for j in range(self.anim.shape[1]):
if name == self._names[j]:
self.corps.append(j)
break
if len(self.corps) != len(corps_names[self.skeleton_type]):
for i in self.corps:
print(self._names[i], end=' ')
print(self.corps, self.skeleton_type, len(self.corps), sep='\n')
raise Exception('Problem in file', file_path)
self.ee_id = []
for i in ee_names[self.skeleton_type]:
self.ee_id.append(corps_names[self.skeleton_type].index(i))
self.joint_num_simplify = len(self.corps)
for i, j in enumerate(self.corps):
self.simplify_map[j] = i
self.inverse_simplify_map[i] = j
self.simplified_name.append(self._names[j])
self.inverse_simplify_map[0] = -1
for i in range(self.anim.shape[1]):
if i in self.details:
self.simplify_map[i] = -1
self.edges = build_edge_topology(self.topology, self.offset)
def __init__(self, args, datasets_groups):
device = torch.device(args.cuda_device if (
torch.cuda.is_available()) else 'cpu')
self.final_data = []
self.length = 0
self.offsets = []
self.joint_topologies = []
self.ee_ids = []
self.means = []
self.vars = []
dataset_num = 0
seed = 19260817
total_length = 10000000
all_datas = []
for datasets in datasets_groups:
offsets_group = []
means_group = []
vars_group = []
dataset_num += len(datasets)
tmp = []
for i, dataset in enumerate(datasets):
new_args = copy.copy(args)
new_args.data_augment = 0
new_args.dataset = dataset
tmp.append(MotionData(new_args))
means_group.append(tmp[-1].mean)
vars_group.append(tmp[-1].var)
file = BVH_file(get_std_bvh(dataset=dataset))
if i == 0:
self.joint_topologies.append(file.topology)
self.ee_ids.append(file.get_ee_id())
new_offset = file.offset
new_offset = torch.tensor(new_offset, dtype=torch.float)
new_offset = new_offset.reshape((1, ) + new_offset.shape)
offsets_group.append(new_offset)
total_length = min(total_length, len(tmp[-1]))
all_datas.append(tmp)
offsets_group = torch.cat(offsets_group, dim=0)
offsets_group = offsets_group.to(device)
means_group = torch.cat(means_group, dim=0).to(device)
vars_group = torch.cat(vars_group, dim=0).to(device)
self.offsets.append(offsets_group)
self.means.append(means_group)
self.vars.append(vars_group)
length_per_skeleton = total_length // dataset_num
for datasets in all_datas:
pt = 0
motions = []
skeleton_idx = []
for dataset in datasets:
motions.append(dataset[pt * length_per_skeleton:(pt + 1) *
length_per_skeleton])
skeleton_idx += [pt] * length_per_skeleton
pt += 1
motions = torch.cat(motions, dim=0)
if self.length != 0 and self.length != len(skeleton_idx):
raise Exception(
'Not equal dataset size for different topologies')
self.length = len(skeleton_idx)
self.final_data.append(MixedData0(args, motions, skeleton_idx))
def __init__(self, args, datasets_groups):
device = torch.device(args.cuda_device if (
torch.cuda.is_available()) else 'cpu')
self.final_data = []
self.length = 0
self.offsets = []
self.joint_topologies = []
self.ee_ids = []
self.means = []
self.vars = []
dataset_num = 0
seed = 19260817
total_length = 10000000
all_datas = []
for datasets in datasets_groups:
offsets_group = []
means_group = []
vars_group = []
dataset_num += len(datasets)
tmp = []
for i, dataset in enumerate(datasets):
new_args = copy.copy(args)
new_args.data_augment = 0
new_args.dataset = dataset
tmp.append(MotionData(new_args))
mean = np.load(
'./datasets/Mixamo/mean_var/{}_mean.npy'.format(dataset))
var = np.load(
'./datasets/Mixamo/mean_var/{}_var.npy'.format(dataset))
mean = torch.tensor(mean)
mean = mean.reshape((1, ) + mean.shape)
var = torch.tensor(var)
var = var.reshape((1, ) + var.shape)
means_group.append(mean)
vars_group.append(var)
file = BVH_file(get_std_bvh(dataset=dataset))
if i == 0:
self.joint_topologies.append(file.topology)
self.ee_ids.append(file.get_ee_id())
new_offset = file.offset
new_offset = torch.tensor(new_offset, dtype=torch.float)
new_offset = new_offset.reshape((1, ) + new_offset.shape)
offsets_group.append(new_offset)
total_length = min(total_length, len(tmp[-1]))
all_datas.append(tmp)
offsets_group = torch.cat(offsets_group, dim=0)
offsets_group = offsets_group.to(device)
means_group = torch.cat(means_group, dim=0).to(device)
vars_group = torch.cat(vars_group, dim=0).to(device)
self.offsets.append(offsets_group)
self.means.append(means_group)
self.vars.append(vars_group)
for datasets in all_datas:
pt = 0
motions = []
skeleton_idx = []
for dataset in datasets:
motions.append(dataset[:])
skeleton_idx += [pt] * len(dataset)
pt += 1
motions = torch.cat(motions, dim=0)
if self.length != 0 and self.length != len(skeleton_idx):
self.length = min(self.length, len(skeleton_idx))
else:
self.length = len(skeleton_idx)
self.final_data.append(MixedData0(args, motions, skeleton_idx))