def gen_data(param_trainable, smpl, data_samples=10000, save_dir=None):
""" Generate random body poses """
X_params = 0.2 * 2 * (np.random.rand(data_samples, 85) - 0.5)
k = np.pi
for param, trainable in param_trainable.items():
if trainable:
param_int = int(param[6:8])
X_params[:,
param_int] = 2 * k * (np.random.rand(data_samples) - 0.5)
X_pcs = []
X_silh = []
for params in X_params:
# Render the point cloud
pc = smpl.set_params(beta=params[72:82],
pose=params[0:72],
trans=params[82:85])
X_pcs.append(pc)
# Now render the silhouette from this
silh = Mesh(pointcloud=pc).render_silhouette(show=False)
X_silh.append(silh)
X_pcs = np.array(X_pcs)
X_silh = np.array(X_silh)
if save_dir is not None:
# Save the generated data in the given location
param_dir = save_dir + "smpl_params/"
pc_dir = save_dir + "pointclouds/"
silh_dir = save_dir + "silhouettes/"
os.system('mkdir ' + param_dir)
os.system('mkdir ' + pc_dir)
os.system('mkdir ' + silh_dir)
faces = smpl.faces
for i in range(data_samples):
sample_id = "sample_{:05d}".format(i + 1)
params = X_params[i]
pc = X_pcs[i]
silh = X_silh[i]
np.savetxt(param_dir + sample_id + ".csv", params, delimiter=",")
print_mesh(pc_dir + sample_id + ".obj", pc, faces)
cv2.imwrite(silh_dir + sample_id + ".png", silh.astype("uint8"))
return X_params, X_pcs, X_silh
def on_epoch_begin(self, epoch, logs=None):
import cv2
outputs = self.model.predict(self.data)
#print(outputs)
gt_params = self.data[1]
pred_params = outputs[0]
print("GT and predicted parameters are equal: " +
str(np.allclose(gt_params, pred_params)))
#print(gt_params)
#print(pred_params)
#exit(1)
gt_pc = self.data[2]
#print(gt_pc)
pred_pc = outputs[2]
right_pred = Mesh(pointcloud=pred_pc[0]).render_silhouette(show=False)
cv2.imwrite("right_pred.png", right_pred.astype("uint8"))
wrong_pred = Mesh(pointcloud=pred_pc[10]).render_silhouette(show=False)
cv2.imwrite("wrong_pred.png", wrong_pred.astype("uint8"))
print_mesh("wrong_mesh.obj", pred_pc[10], faces)
print_mesh("right_mesh.obj", pred_pc[0], faces)
#print(pred_pc)
print("GT and predicted point clouds are equal: " +
str(np.allclose(gt_pc, pred_pc)))
close = np.array([
np.int(np.allclose(gt_pc[i], pred_pc[i]))
for i in range(gt_pc.shape[0])
])
#print([np.allclose(gt_pc[i], pred_pc[i]) for i in range(gt_pc.shape[0])])
not_close = np.array([not value for value in close])
close_sum = np.sum(close)
#print("Num close pc: " + str(close_sum))
not_close_gt = gt_pc[not_close]
not_close_pred = pred_pc[not_close]
#print(not_close_pred[0])
#exit(1)
diff_not_close = not_close_gt - not_close_pred
import pandas as pd
diff_df = pd.DataFrame(diff_not_close[10])
diff_df.to_csv("diff.csv")
dist_not_close = np.sum(np.square(diff_not_close), axis=-1)
dist_df = pd.DataFrame(dist_not_close[10])
dist_df.to_csv("dist.csv")
mean_not_close = np.mean(dist_not_close, axis=1)
#print(mean_not_close)
gt_example = not_close_gt[10]
pred_example = not_close_pred[10]
gt_silh = Mesh(pointcloud=gt_example).render_silhouette(show=False)
pred_silh = Mesh(pointcloud=pred_example).render_silhouette(show=False)
diff_silh = (gt_silh != pred_silh) * 255
all_silh = np.concatenate([gt_silh, pred_silh, diff_silh])
cv2.imwrite("silh_comp.png", all_silh.astype("uint8"))
#exit(1)
euc_dist = np.square(np.subtract(gt_pc, pred_pc))
#print(euc_dist[0])
euc_dist_summed = np.sum(euc_dist, axis=-1)
#print(euc_dist_summed[0])
actual_loss = np.mean(euc_dist_summed, axis=1)
#print(actual_loss)
actual_loss_sum = np.sum(actual_loss, axis=0)
#print(actual_loss_sum)
mean_loss = np.mean(actual_loss)
print("Calculated mean loss: {}".format(mean_loss))
print("Model mean loss: {}".format(np.mean(outputs[3])))
