default=0,
help='if 1, projects predicted correspondences point on target mesh')
parser.add_argument(
'--randomize',
type=int,
default=0,
help='if 1, projects predicted correspondences point on target mesh')
opt = parser.parse_args()
opt.HR = my_utils.int_2_boolean(opt.HR)
opt.LR_input = my_utils.int_2_boolean(opt.LR_input)
opt.clean = my_utils.int_2_boolean(opt.clean)
opt.scale = my_utils.int_2_boolean(opt.scale)
opt.project_on_target = my_utils.int_2_boolean(opt.project_on_target)
opt.randomize = my_utils.int_2_boolean(opt.randomize)
my_utils.plant_seeds(randomized_seed=opt.randomize)
inf = Inference(HR=opt.HR,
nepoch=opt.nepoch,
model_path=opt.model_path,
num_points=opt.num_points,
num_angles=opt.num_angles,
clean=opt.clean,
scale=opt.scale,
project_on_target=opt.project_on_target,
LR_input=opt.LR_input)
# inf.reconstruct((opt.inputA))
inf.forward(opt.inputA, opt.inputB)
# inf.forward(opt.inputA, opt.inputA)
from __future__ import print_function
import sys
sys.path.append('./auxiliary/')
sys.path.append('/app/python/')
sys.path.append('./')
import my_utils
my_utils.plant_seeds(randomized_seed=False)
print("fixed seed")
import argparse
import random
import numpy as np
import torch
import torch.optim as optim
import pointcloud_processor
from dataset import *
from model import *
from ply import *
import os
import json
import datetime
import visdom
# =============PARAMETERS======================================== #
parser = argparse.ArgumentParser()
parser.add_argument('--batchSize',
type=int,
default=32,
help='input batch size')
parser.add_argument('--workers',
type=int,
help='number of data loading workers',
def forward(opt):
"""
Takes an input and a target mesh. Deform input in output and propagate a
manually defined high frequency from the oinput to the output
:return:
"""
my_utils.plant_seeds(randomized_seed=opt.randomize)
os.makedirs(opt.output_dir, exist_ok=True)
trainer = t.Trainer(opt)
trainer.build_dataset_train_for_matching()
trainer.build_dataset_test_for_matching()
trainer.build_network()
trainer.build_losses()
trainer.network.eval()
if opt.eval_list and os.path.isfile(opt.eval_list):
source_target_files = np.loadtxt(opt.eval_list, dtype=str)
source_target_files = source_target_files.tolist()
for i, st in enumerate(source_target_files):
source, target = st
cat1, fname1 = source.split('/')
fname1 = os.path.splitext(fname1)[0]
cat2, fname2 = target.split('/')
fname2 = os.path.splitext(fname2)[0]
if len(opt.shapenetv1_path) > 0:
source_target_files[i] = (os.path.join(opt.shapenetv1_path,
cat1, fname1,
"model.obj"),
os.path.join(opt.shapenetv1_path,
cat2, fname2,
"model.obj"))
elif len(opt.shapenetv2_path) > 0:
source_target_files[i] = (os.path.join(opt.shapenetv2_path,
cat1, fname1, "models",
"model_normalized.obj"),
os.path.join(opt.shapenetv2_path,
cat2, fname2, "models",
"model_normalized.obj"))
elif (opt.eval_source != "" and opt.eval_source[-4:] == ".txt") and (
opt.eval_target != "" and opt.eval_target[-4:] == ".txt"):
source_target_files = [
(figure_2_3.convert_path(opt.shapenetv1_path, opt.eval_source),
figure_2_3.convert_path(opt.shapenetv1_path, opt.eval_target))
]
rot_mat = get_3D_rot_matrix(1, np.pi / 2)
rot_mat_rev = get_3D_rot_matrix(1, -np.pi / 2)
isV2 = len(opt.shapenetv2_path) > 0
for i, source_target in enumerate(source_target_files):
basename = get_model_id(source_target[0], isV2) + "-" + get_model_id(
source_target[1], isV2)
path_deformed = os.path.join(opt.output_dir, basename + "-Sab.ply")
path_source = os.path.join(opt.output_dir, basename + "-Sa.ply")
path_target = os.path.join(opt.output_dir, basename + "-Sb.ply")
mesh_path = source_target[0]
print(mesh_path)
source_mesh_edge = get_shapenet_model.link(mesh_path)
mesh_path = source_target[1]
target_mesh_edge = get_shapenet_model.link(mesh_path)
print("Deforming source in target")
source = source_mesh_edge.vertices
target = target_mesh_edge.vertices
pymesh.save_mesh_raw(path_source,
source,
source_mesh_edge.faces,
ascii=True)
pymesh.save_mesh_raw(path_target,
target,
target_mesh_edge.faces,
ascii=True)
if len(opt.shapenetv2_path) > 0:
source = source.dot(rot_mat)
target = target.dot(rot_mat)
source = torch.from_numpy(source).cuda().float().unsqueeze(0)
target = torch.from_numpy(target).cuda().float().unsqueeze(0)
with torch.no_grad():
source, _, _, _, _ = loss.forward_chamfer(
trainer.network,
source,
target,
local_fix=None,
distChamfer=trainer.distChamfer)
try:
source = source.squeeze().cpu().detach().numpy()
if len(opt.shapenetv2_path) > 0:
source = source.dot(rot_mat_rev)
P2_P1_mesh = pymesh.form_mesh(vertices=source,
faces=source_mesh_edge.faces)
pymesh.save_mesh(path_deformed, P2_P1_mesh, ascii=True)
# print("computing signal tranfer form source to target")
# high_frequencies.high_frequency_propagation(path_source, path_deformed, path_target)
except Exception as e:
print(e)
import pdb
pdb.set_trace()
path_deformed = path_deformed[:-4] + ".pts"
save_pts(path_deformed, source.squeeze().cpu().detach().numpy())
def get_criterion_shape(opt):
return_dict = {}
my_utils.plant_seeds(randomized_seed=opt.randomize)
trainer = t.Trainer(opt)
trainer.build_dataset_train_for_matching()
trainer.build_dataset_test_for_matching()
trainer.build_network()
trainer.build_losses()
trainer.network.eval()
# Load input mesh
exist_P2_label = True
try:
mesh_path = opt.eval_get_criterions_for_shape # Ends in .txt
points = np.loadtxt(mesh_path)
points = torch.from_numpy(points).float()
# Normalization is done before resampling !
P2 = normalize_points.BoundingBox(points[:, :3])
P2_label = points[:, 6].data.cpu().numpy()
except:
mesh_path = opt.eval_get_criterions_for_shape # Ends in .obj
source_mesh_edge = get_shapenet_model.link(mesh_path)
P2 = torch.from_numpy(source_mesh_edge.vertices)
exist_P2_label = False
min_k = Min_k(opt.k_max_eval)
max_k = Max_k(opt.k_max_eval)
points_train_list = []
point_train_paths = []
labels_train_list = []
iterator_train = trainer.dataloader_train.__iter__()
for find_best in range(opt.num_shots_eval):
try:
points_train, _, _, file_path = iterator_train.next()
points_train_list.append(
points_train[:, :, :3].contiguous().cuda().float())
point_train_paths.append(file_path)
labels_train_list.append(
points_train[:, :, 6].contiguous().cuda().float())
except:
break
# ========Loop on test examples======================== #
with torch.no_grad():
P2 = P2[:, :3].unsqueeze(0).contiguous().cuda().float()
P2_latent = trainer.network.encode(
P2.transpose(1, 2).contiguous(),
P2.transpose(1, 2).contiguous())
# Chamfer (P0_P2)
P0_P2_list = list(
map(
lambda x: loss.forward_chamfer(trainer.network,
P2,
x,
local_fix=None,
distChamfer=trainer.distChamfer
), points_train_list))
# Compute Chamfer (P2_P0)
P2_P0_list = list(
map(
lambda x: loss.forward_chamfer(trainer.network,
x,
P2,
local_fix=None,
distChamfer=trainer.distChamfer
), points_train_list))
predicted_ours_P2_P0_list = list(
map(lambda x, y: x.view(-1)[y[4].view(-1).data.long()].view(1, -1),
labels_train_list, P2_P0_list))
if exist_P2_label:
iou_ours_list = list(
map(
lambda x: miou_shape.miou_shape(x.squeeze().cpu().numpy(
), P2_label, trainer.parts), predicted_ours_P2_P0_list))
top_k_idx, top_k_values = max_k(iou_ours_list)
return_dict["oracle"] = point_train_paths[top_k_idx[0]][0]
predicted_ours_P2_P0_list = list(
map(lambda x, y: x.view(-1)[y[4].view(-1).data.long()].view(1, -1),
labels_train_list, P2_P0_list))
predicted_ours_P2_P0_list = torch.cat(predicted_ours_P2_P0_list)
# Compute NN
P2_P0_NN_list = list(
map(lambda x: loss.distChamfer(x, P2), points_train_list))
predicted_NN_P2_P0_list = list(
map(lambda x, y: x.view(-1)[y[3].view(-1).data.long()].view(1, -1),
labels_train_list, P2_P0_NN_list))
predicted_NN_P2_P0_list = torch.cat(predicted_NN_P2_P0_list)
# NN
NN_chamferL2_list = list(
map(lambda x: loss.chamferL2(x[0], x[1]), P2_P0_NN_list))
top_k_idx, top_k_values = min_k(NN_chamferL2_list)
return_dict["NN_criterion"] = point_train_paths[top_k_idx[0]][0]
# Chamfer ours
chamfer_list = list(
map(lambda x: loss.chamferL2(x[1], x[2]), P2_P0_list))
top_k_idx, top_k_values = min_k(chamfer_list)
return_dict["chamfer_criterion"] = point_train_paths[top_k_idx[0]][0]
# NN in latent space
P0_latent_list = list(
map(
lambda x: trainer.network.encode(
x.transpose(1, 2).contiguous(),
x.transpose(1, 2).contiguous()), points_train_list))
cosine_list = list(
map(lambda x: loss.cosine(x, P2_latent), P0_latent_list))
top_k_idx, top_k_values = min_k(cosine_list)
return_dict["cosine_criterion"] = point_train_paths[top_k_idx[0]][0]
# Cycle 2
P0_P2_cycle_list = list(
map(lambda x, y: loss.batch_cycle_2(x[0], y[3], 1), P0_P2_list,
P2_P0_list))
P0_P2_cycle_list = list(
map(lambda x, y: loss.L2(x, y), P0_P2_cycle_list,
points_train_list))
P2_P0_cycle_list = list(
map(lambda x, y: loss.batch_cycle_2(x[0], y[3], 1), P2_P0_list,
P0_P2_list))
P2_P0_cycle_list = list(map(lambda x: loss.L2(x, P2),
P2_P0_cycle_list))
# Cycle 2 both sides
both_cycle_list = list(
map(lambda x, y: x * y, P0_P2_cycle_list, P2_P0_cycle_list))
both_cycle_list = np.power(both_cycle_list, 1.0 / 2.0).tolist()
top_k_cycle2_idx, top_k_values = min_k(both_cycle_list)
return_dict["cycle_criterion"] = point_train_paths[
top_k_cycle2_idx[0]][0]
pprint.pprint(return_dict)
return return_dict
def forward(opt):
"""
Takes an input and a target mesh. Deform input in output and propagate a
manually defined high frequency from the oinput to the output
:return:
"""
my_utils.plant_seeds(randomized_seed=opt.randomize)
pdb.set_trace()
trainer = t.Trainer(opt)
trainer.build_dataset_train_for_matching()
trainer.build_dataset_test_for_matching()
trainer.build_network()
trainer.build_losses()
trainer.network.eval()
if opt.eval_source[-4:] == ".txt":
opt.eval_source = figure_2_3.convert_path(opt.shapenetv1_path,
opt.eval_source)
if opt.eval_target[-4:] == ".txt":
opt.eval_target = figure_2_3.convert_path(opt.shapenetv1_path,
opt.eval_target)
path_deformed = os.path.join("./figures/forward_input_target/",
opt.eval_source[-42:-10] + "deformed.ply")
path_source = os.path.join("./figures/forward_input_target/",
opt.eval_source[-42:-10] + ".ply")
path_target = os.path.join(
"./figures/forward_input_target/",
opt.eval_source[-42:-10] + "_" + opt.eval_target[-42:-10] + ".ply")
mesh_path = opt.eval_source
print(mesh_path)
source_mesh_edge = get_shapenet_model.link(mesh_path)
mesh_path = opt.eval_target
target_mesh_edge = get_shapenet_model.link(mesh_path)
pymesh.save_mesh(path_source, source_mesh_edge, ascii=True)
pymesh.save_mesh(path_target, target_mesh_edge, ascii=True)
print("Deforming source in target")
source = torch.from_numpy(
source_mesh_edge.vertices).cuda().float().unsqueeze(0)
target = torch.from_numpy(
target_mesh_edge.vertices).cuda().float().unsqueeze(0)
with torch.no_grad():
source, _, _, _, _ = loss.forward_chamfer(
trainer.network,
source,
target,
local_fix=None,
distChamfer=trainer.distChamfer)
P2_P1_mesh = pymesh.form_mesh(
vertices=source.squeeze().cpu().detach().numpy(),
faces=source_mesh_edge.faces)
pymesh.save_mesh(path_deformed, P2_P1_mesh, ascii=True)
print("computing signal tranfer form source to target")
high_frequencies.high_frequency_propagation(path_source, path_deformed,
path_target)
