def __init__(self, HR=0, nepoch=3000, model_path='trained_models/sup_human_network_last.pth', num_points=6890, num_angles=100, clean=1, scale=1, project_on_target=0, save_path=None, LR_input=True): self.LR_input = LR_input self.HR = HR self.nepoch = nepoch self.model_path = model_path self.num_points = num_points self.num_angles = num_angles self.clean = clean self.scale = scale self.project_on_target = project_on_target self.distChamfer = ext.chamferDist() # load network self.network = model.AE_AtlasNet_Humans(num_points=self.num_points) self.network.cuda() self.network.apply(my_utils.weights_init) if self.model_path != '': print("Reload weights from : ", self.model_path) self.network.load_state_dict(torch.load(self.model_path)) self.network.eval() self.neigh = NearestNeighbors(1, 0.4) self.mesh_ref = trimesh.load("./data/template/template_dense.ply", process=False) self.mesh_ref_LR = trimesh.load("./data/template/template.ply", process=False) # load colors self.red_LR = np.load("./data/template/red_LR.npy").astype("uint8") self.green_LR = np.load("./data/template/green_LR.npy").astype("uint8") self.blue_LR = np.load("./data/template/blue_LR.npy").astype("uint8") self.red_HR = np.load("./data/template/red_HR.npy").astype("uint8") self.green_HR = np.load("./data/template/green_HR.npy").astype("uint8") self.blue_HR = np.load("./data/template/blue_HR.npy").astype("uint8") self.save_path ="./results_HR_truth" #save_path
def test_chamfer(): distChamfer = ext.chamferDist() p1 = torch.rand(4, 100, 3).cuda() p2 = torch.rand(4, 100, 3).cuda() points1 = Variable(p1, requires_grad=True) points2 = Variable(p2) dist1, dist2, = distChamfer(points1, points2) loss = torch.sum(dist1) print(loss) loss.backward() print(points1.grad, points2.grad) mydist1, mydist2 = mydistChamfer(points1, points2) d1 = (dist1 - mydist1)**2 d2 = (dist2 - mydist2)**2 assert ( torch.sum(d1) + torch.sum(d1) < 0.00000001 ), "chamfer cuda and chamfer normal are not giving the same results"
import argparse import random import numpy as np import torch import torch.optim as optim import torch.nn as nn import model import ply import time from sklearn.neighbors import NearestNeighbors sys.path.append("./extension/") sys.path.append("/app/python/") import dist_chamfer as ext distChamfer = ext.chamferDist() import trimesh import torch import pandas as pd import os os.environ['CUDA_VISIBLE_DEVICES'] = "0" from mpl_toolkits import mplot3d import matplotlib.pyplot as plt import pointcloud_processor class SMPL_t(object): def __init__(self, HR=0, nepoch=3000, num_points=6890, num_angles=100,save_path=None): self.save_path = save_path self.right_arm=np.load("./data/output/left_hand_indices_t.npy") self.red_LR = np.load("./data/template/red_LR.npy").astype("uint8")
from __future__ import print_function import sys import torch sys.path.append("./extension/") import dist_chamfer as ext distChamferL2 = ext.chamferDist() def ChamferLoss(target, prediction): dist1, dist2 = distChamferL2(target, prediction) loss = torch.mean(dist1) + torch.mean(dist2) return loss class LOSS_LIST: """list of all the model""" def __init__(self): self.losses = { "AtlasNet": ChamferLoss, "PatchDeformation": ChamferLoss, "PointTranslation": ChamferLoss, } def load(self, options): loss = self.losses[options.model] return loss
def __init__(self, model): super(FullModel, self).__init__() self.model = model self.EMD = emd.emdModule() self.CD = cd.chamferDist()
from model import * from utils import * import argparse import random import numpy as np import torch import h5py import os import visdom sys.path.append("./emd/") import emd_module as emd sys.path.append("./chamfer/") import dist_chamfer as cd from dataset import resample_pcd, read_points EMD = emd.emdModule() CD = cd.chamferDist() def points_save(points, colors, root='pcds/regions', child='all', pfile=''): os.makedirs(root, exist_ok=True) os.makedirs(root + '/' + child, exist_ok=True) pcd = o3d.PointCloud() pcd.points = o3d.Vector3dVector(np.float32(points)) pcd.colors = o3d.Vector3dVector(np.float32(colors)) o3d.write_point_cloud(os.path.join(root, '%s.pcd' % pfile), pcd, write_ascii=True, compressed=True) parser = argparse.ArgumentParser()
import torch.optim as optim import torch.utils.data import torchvision.datasets as dset import torchvision.transforms as transforms import torchvision.utils as vutils import torch.nn.functional as F import torch.cuda as cuda from pic2points import pic2points from torch.nn.parallel import DataParallel from sklearn.model_selection import train_test_split from data_loader import ShapeNet from torch.autograd import Variable import torch from dist_chamfer import chamferDist distChamfer = chamferDist() parser = argparse.ArgumentParser() parser.add_argument('--batchSize', type=int, default=8, help='input batch size') parser.add_argument('--num_points', type=int, default=2048, help='input batch size') parser.add_argument('--workers', type=int, help='number of data loading workers', default=8) parser.add_argument('--nepoch',
import torch import dist_chamfer dist = dist_chamfer.chamferDist() with torch.enable_grad(): p1 = torch.rand(10, 1000, 6) p2 = torch.rand(10, 1500, 6) p1.requires_grad = True p2.requires_grad = True points1 = p1.cuda() points2 = p2.cuda() cost, _ = dist(points1, points2) print(cost) loss = torch.sum(cost) print(loss) loss.backward() print(points1.grad, points2.grad)
import torch.optim as optim from torch.nn.parameter import Parameter import torch.utils.data import torchvision.transforms as transforms import torchvision.utils as vutils from torch.autograd import Variable from PIL import Image import numpy as np import matplotlib.pyplot as plt import pdb import torch.nn.functional as F import resnet import math sys.path.append("./ext/") import dist_chamfer as ext cd = ext.chamferDist() knn = ext.knn class CurveCDLoss(nn.Module): def __init__(self, k=8): super(CurveCDLoss, self).__init__() self.k_ = k def forward(self, xyz1, xyz2, w=0.1): c1 = self.curve(xyz1) s1 = torch.cat([xyz1, w * c1], dim=2) c2 = self.curve(xyz2) s2 = torch.cat([xyz2, w * c2], dim=2) d1, d2 = cd(s1.contiguous(), s2.contiguous()) loss = (torch.mean(d1)) + (torch.mean(d2))