def __init__(self, geometric_model='affine', use_cuda=True, grid_size=20):
super(TransformedGridLoss, self).__init__()
self.geometric_model = geometric_model
if self.geometric_model == 'vqmt3d':
self.get_mat_fun = None
elif self.geometric_model == 'affine_simple' or self.geometric_model == 'affine_simple_4':
self.get_mat_fun = affine_mat_from_simple
elif self.geometric_model == 'rotate':
self.get_mat_fun = get_rotate_matrix
elif self.geometric_model == 'scale':
self.get_mat_fun = get_scale_matrix
elif self.geometric_model == 'shift_y':
self.get_mat_fun = get_shift_y_matrix
else:
raise NotImplementedError(
'Specified geometric model is unsupported')
# define virtual grid of points to be transformed
axis_coords = np.linspace(-1, 1, grid_size)
self.N = grid_size * grid_size
X, Y = np.meshgrid(axis_coords, axis_coords)
X = np.reshape(X, (1, 1, self.N))
Y = np.reshape(Y, (1, 1, self.N))
P = np.concatenate((X, Y), 1)
self.P = Variable(torch.FloatTensor(P), requires_grad=False)
self.pointTnf = PointTnf(use_cuda=use_cuda)
if use_cuda:
self.P = self.P.cuda()
def pck_metric(batch,batch_start_idx,theta_aff,theta_tps,theta_aff_tps,model_tps,stats,args,use_cuda=True):
alpha = args.pck_alpha
do_aff = theta_aff is not None
do_tps = theta_tps is not None
do_aff_tps = theta_aff_tps is not None
source_im_size = batch['source_im_size']
target_im_size = batch['target_im_size']
source_points = batch['source_points']
target_points = batch['target_points']
# Instantiate point transformer
pt = PointTnf(use_cuda=use_cuda,
tps_reg_factor=args.tps_reg_factor)
# warp points with estimated transformations
target_points_norm = PointsToUnitCoords(target_points,target_im_size)
if do_aff:
# do affine only
warped_points_aff_norm = pt.affPointTnf(theta_aff,target_points_norm)
warped_points_aff = PointsToPixelCoords(warped_points_aff_norm,source_im_size)
if do_tps:
# do tps only
warped_points_tps_norm = pt.defPointTnf(theta_tps,target_points_norm,model_tps)
warped_points_tps = PointsToPixelCoords(warped_points_tps_norm,source_im_size)
if do_aff_tps:
# do tps+affine
warped_points_aff_tps_norm = pt.defPointTnf(theta_aff_tps,target_points_norm,model_tps)
warped_points_aff_tps_norm = pt.affPointTnf(theta_aff,warped_points_aff_tps_norm)
warped_points_aff_tps = PointsToPixelCoords(warped_points_aff_tps_norm,source_im_size)
L_pck = batch['L_pck'].data
current_batch_size=batch['source_im_size'].size(0)
indices = range(batch_start_idx,batch_start_idx+current_batch_size)
# import pdb; pdb.set_trace()
if do_aff:
pck_aff = pck(source_points.data, warped_points_aff.data, L_pck, alpha)
if do_tps:
pck_tps = pck(source_points.data, warped_points_tps.data, L_pck, alpha)
if do_aff_tps:
pck_aff_tps = pck(source_points.data, warped_points_aff_tps.data, L_pck, alpha)
if do_aff:
stats['aff']['pck'][indices] = pck_aff.unsqueeze(1).cpu().numpy()
if do_tps:
stats['tps']['pck'][indices] = pck_tps.unsqueeze(1).cpu().numpy()
if do_aff_tps:
stats['aff_tps']['pck'][indices] = pck_aff_tps.unsqueeze(1).cpu().numpy()
return stats
def flow_metrics(batch,batch_start_idx,theta_1,theta_2,geometric_model_1,geometric_model_2,stats,args,use_cuda=True):
two_stage=(geometric_model_2 is not None)
result_path=args.flow_output_dir
pt=PointTnf(use_cuda=use_cuda)
if geometric_model_1=='affine':
tnf_1 = pt.affPointTnf
elif geometric_model_1=='hom':
tnf_1 = pt.homPointTnf
elif geometric_model_1=='tps':
tnf_1 = pt.tpsPointTnf
if two_stage:
if geometric_model_2=='affine':
tnf_2 = pt.affPointTnf
elif geometric_model_2=='hom':
tnf_2 = pt.homPointTnf
elif geometric_model_2=='tps':
tnf_2 = pt.tpsPointTnf
batch_size=batch['source_im_size'].size(0)
for b in range(batch_size):
h_src = int(batch['source_im_size'][b,0].data.cpu().numpy())
w_src = int(batch['source_im_size'][b,1].data.cpu().numpy())
h_tgt = int(batch['target_im_size'][b,0].data.cpu().numpy())
w_tgt = int(batch['target_im_size'][b,1].data.cpu().numpy())
grid_X,grid_Y = np.meshgrid(np.linspace(-1,1,w_tgt),np.linspace(-1,1,h_tgt))
grid_X = torch.FloatTensor(grid_X).unsqueeze(0).unsqueeze(3)
grid_Y = torch.FloatTensor(grid_Y).unsqueeze(0).unsqueeze(3)
grid_X = Variable(grid_X,requires_grad=False)
grid_Y = Variable(grid_Y,requires_grad=False)
if use_cuda:
grid_X = grid_X.cuda()
grid_Y = grid_Y.cuda()
grid_X_vec = grid_X.view(1,1,-1)
grid_Y_vec = grid_Y.view(1,1,-1)
grid_XY_vec = torch.cat((grid_X_vec,grid_Y_vec),1)
def pointsToGrid (x,h_tgt=h_tgt,w_tgt=w_tgt): return x.contiguous().view(1,2,h_tgt,w_tgt).transpose(1,2).transpose(2,3)
grid_1 = pointsToGrid(tnf_1(theta_1[b,:].unsqueeze(0),grid_XY_vec))
flow_1 = th_sampling_grid_to_np_flow(source_grid=grid_1,h_src=h_src,w_src=w_src)
flow_1_path = os.path.join(result_path,geometric_model_1,batch['flow_path'][b])
create_file_path(flow_1_path)
write_flo_file(flow_1,flow_1_path)
if two_stage:
grid_1_2 = pointsToGrid(tnf_1(theta_1[b,:].unsqueeze(0),tnf_2(theta_2[b,:].unsqueeze(0),grid_XY_vec)))
flow_1_2 = th_sampling_grid_to_np_flow(source_grid=grid_1_2,h_src=h_src,w_src=w_src)
flow_1_2_path = os.path.join(result_path,geometric_model_1+'_'+geometric_model_2,batch['flow_path'][b])
create_file_path(flow_1_2_path)
write_flo_file(flow_1_2,flow_1_2_path)
return stats
def __init__(self,
transform='affine',
use_cuda=True,
dist_metric='L2'):
super(TransitivityLoss, self).__init__()
self.pointTnf = PointTnf(use_cuda=use_cuda)
self.dist_metric = dist_metric
self.transform = transform
def pck_metric(batch,batch_start_idx,theta_1,theta_2,geometric_model_1,geometric_model_2,stats,args,use_cuda=True):
two_stage=(geometric_model_2 is not None)
alpha = args.pck_alpha
source_im_size = batch['source_im_size']
target_im_size = batch['target_im_size']
source_points = batch['source_points']
target_points = batch['target_points']
# Instantiate point transformer
pt = PointTnf(use_cuda=use_cuda,
tps_reg_factor=args.tps_reg_factor)
if geometric_model_1=='affine':
tnf_1 = pt.affPointTnf
elif geometric_model_1=='hom':
tnf_1 = pt.homPointTnf
elif geometric_model_1=='tps':
tnf_1 = pt.tpsPointTnf
if two_stage:
if geometric_model_2=='affine':
tnf_2 = pt.affPointTnf
elif geometric_model_2=='hom':
tnf_2 = pt.homPointTnf
elif geometric_model_2=='tps':
tnf_2 = pt.tpsPointTnf
# warp points with estimated transformations
target_points_norm = PointsToUnitCoords(target_points,target_im_size)
# compute points stage 1 only
warped_points_1_norm = tnf_1(theta_1,target_points_norm)
warped_points_1 = PointsToPixelCoords(warped_points_1_norm,source_im_size)
if two_stage:
# do tps+affine
warped_points_1_2_norm = tnf_2(theta_2,target_points_norm)
warped_points_1_2_norm = tnf_1(theta_1,warped_points_1_2_norm)
warped_points_1_2 = PointsToPixelCoords(warped_points_1_2_norm,source_im_size)
L_pck = batch['L_pck'].data
current_batch_size=batch['source_im_size'].size(0)
indices = range(batch_start_idx,batch_start_idx+current_batch_size)
# compute PCK
pck_1 = pck(source_points.data, warped_points_1.data, L_pck, alpha)
stats[geometric_model_1]['pck'][indices] = pck_1.unsqueeze(1).cpu().numpy()
if two_stage:
pck_1_2 = pck(source_points.data, warped_points_1_2.data, L_pck, alpha)
stats[geometric_model_1+'_'+geometric_model_2]['pck'][indices] = pck_1_2.unsqueeze(1).cpu().numpy()
return stats
def __init__(self, geometric_model='affine', grid_size=20):
self.geometric_model = geometric_model
axis_coords = np.linspace(-1,1,grid_size)
self.N = grid_size*grid_size
X, Y = np.meshgrid(axis_coords, axis_coords)
X = np.reshape(X, [1,1,self.N])
Y = np.reshape(Y, [1,1,self.N])
P = np.concatenate((X,Y),1)
self.P = P
self.pointTnf = PointTnf()
def flow_metrics(batch,batch_start_idx,theta_aff,theta_tps,theta_aff_tps,model_tps,stats,args,use_cuda=True):
result_path=args.flow_output_dir
do_aff = theta_aff is not None
do_tps = theta_tps is not None
do_aff_tps = theta_aff_tps is not None
pt=PointTnf(use_cuda=use_cuda)
batch_size=batch['source_im_size'].size(0)
for b in range(batch_size):
h_src = int(batch['source_im_size'][b,0].data.cpu().numpy())
w_src = int(batch['source_im_size'][b,1].data.cpu().numpy())
h_tgt = int(batch['target_im_size'][b,0].data.cpu().numpy())
w_tgt = int(batch['target_im_size'][b,1].data.cpu().numpy())
grid_X,grid_Y = np.meshgrid(np.linspace(-1,1,w_tgt),np.linspace(-1,1,h_tgt))
grid_X = torch.FloatTensor(grid_X).unsqueeze(0).unsqueeze(3)
grid_Y = torch.FloatTensor(grid_Y).unsqueeze(0).unsqueeze(3)
grid_X = Variable(grid_X,requires_grad=False)
grid_Y = Variable(grid_Y,requires_grad=False)
if use_cuda:
grid_X = grid_X.cuda()
grid_Y = grid_Y.cuda()
grid_X_vec = grid_X.view(1,1,-1)
grid_Y_vec = grid_Y.view(1,1,-1)
grid_XY_vec = torch.cat((grid_X_vec,grid_Y_vec),1)
def pointsToGrid (x,h_tgt=h_tgt,w_tgt=w_tgt): return x.contiguous().view(1,2,h_tgt,w_tgt).transpose(1,2).transpose(2,3)
idx = batch_start_idx+b
if do_aff:
grid_aff = pointsToGrid(pt.affPointTnf(theta_aff[b,:].unsqueeze(0),grid_XY_vec))
flow_aff = th_sampling_grid_to_np_flow(source_grid=grid_aff,h_src=h_src,w_src=w_src)
flow_aff_path = os.path.join(result_path,'aff',batch['flow_path'][b])
create_file_path(flow_aff_path)
write_flo_file(flow_aff,flow_aff_path)
if do_tps:
grid_tps = pointsToGrid(pt.defPointTnf(theta_tps[b,:].unsqueeze(0),grid_XY_vec,model_tps))
flow_tps = th_sampling_grid_to_np_flow(source_grid=grid_tps,h_src=h_src,w_src=w_src)
flow_tps_path = os.path.join(result_path,'tps',batch['flow_path'][b])
create_file_path(flow_tps_path)
write_flo_file(flow_tps,flow_tps_path)
if do_aff_tps:
grid_aff_tps = pointsToGrid(pt.affPointTnf(theta_aff[b,:].unsqueeze(0),pt.defPointTnf(theta_aff_tps[b,:].unsqueeze(0),grid_XY_vec,model_tps)))
flow_aff_tps = th_sampling_grid_to_np_flow(source_grid=grid_aff_tps,h_src=h_src,w_src=w_src)
flow_aff_tps_path = os.path.join(result_path,'aff_tps',batch['flow_path'][b])
create_file_path(flow_aff_tps_path)
write_flo_file(flow_aff_tps,flow_aff_tps_path)
idx = batch_start_idx+b
return stats
def __init__(self, use_cuda=True, grid_size=20):
super(SequentialGridLoss, self).__init__()
self.N = grid_size * grid_size
# define virtual grid of points to be transformed
axis_coords = np.linspace(-1, 1, grid_size)
X,Y = np.meshgrid(axis_coords, axis_coords)
X = X.ravel()[None, None, ...]
Y = Y.ravel()[None, None, ...]
P = np.concatenate((X, Y), axis=1)
self.P = torch.tensor(P, dtype=torch.float32, requires_grad=False)
self.pointTnf = PointTnf(use_cuda=use_cuda)
if use_cuda:
self.P = self.P.cuda()
def __init__(self, geometric_model='affine', use_cuda=True, grid_size=20):
super(TransformedGridLoss, self).__init__()
self.geometric_model = geometric_model
# define virtual grid of points to be transformed
axis_coords = np.linspace(-1, 1, grid_size)
self.N = grid_size * grid_size
X, Y = np.meshgrid(axis_coords, axis_coords)
X = np.reshape(X, (1, 1, self.N))
Y = np.reshape(Y, (1, 1, self.N))
P = np.concatenate((X, Y), 1)
self.P = Variable(torch.FloatTensor(P), requires_grad=False)
self.pointTnf = PointTnf(use_cuda=use_cuda)
if use_cuda:
self.P = self.P.cuda()
def flow_metrics(batch, batch_start_idx, matches, stats, args, use_cuda=True):
result_path = args.flow_output_dir
pt = PointTnf(use_cuda=use_cuda)
batch_size = batch['source_im_size'].size(0)
for b in range(batch_size):
h_src = int(batch['source_im_size'][b, 0].data.cpu().numpy())
w_src = int(batch['source_im_size'][b, 1].data.cpu().numpy())
h_tgt = int(batch['target_im_size'][b, 0].data.cpu().numpy())
w_tgt = int(batch['target_im_size'][b, 1].data.cpu().numpy())
grid_X, grid_Y = np.meshgrid(np.linspace(-1, 1, w_tgt),
np.linspace(-1, 1, h_tgt))
grid_X = torch.FloatTensor(grid_X).unsqueeze(0).unsqueeze(3)
grid_Y = torch.FloatTensor(grid_Y).unsqueeze(0).unsqueeze(3)
grid_X = Variable(grid_X, requires_grad=False)
grid_Y = Variable(grid_Y, requires_grad=False)
if use_cuda:
grid_X = grid_X.cuda()
grid_Y = grid_Y.cuda()
grid_X_vec = grid_X.view(1, 1, -1)
grid_Y_vec = grid_Y.view(1, 1, -1)
grid_XY_vec = torch.cat((grid_X_vec, grid_Y_vec), 1)
def pointsToGrid(x, h_tgt=h_tgt, w_tgt=w_tgt):
return x.contiguous().view(1, 2, h_tgt,
w_tgt).transpose(1, 2).transpose(2, 3)
idx = batch_start_idx + b
source_im_size = batch['source_im_size']
warped_points_norm = bilinearInterpPointTnf(matches, grid_XY_vec)
# warped_points = PointsToPixelCoords(warped_points_norm,source_im_size)
warped_points = pointsToGrid(warped_points_norm)
# grid_aff = pointsToGrid(pt.affPointTnf(theta_aff[b, :].unsqueeze(0), grid_XY_vec))
flow_aff = th_sampling_grid_to_np_flow(source_grid=warped_points,
h_src=h_src,
w_src=w_src)
flow_aff_path = os.path.join(result_path, 'nc', batch['flow_path'][b])
create_file_path(flow_aff_path)
write_flo_file(flow_aff, flow_aff_path)
idx = batch_start_idx + b
return stats
def __init__(self,
csv_file,
dataset_path,
dataset_size=None,
output_size=(240, 240),
transform=None,
category=None,
random_crop=True):
self.category_names = [
'aeroplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus', 'car',
'cat', 'chair', 'cow', 'diningtable', 'dog', 'horse', 'motorbike',
'person', 'pottedplant', 'sheep', 'sofa', 'train', 'tvmonitor'
]
self.random_crop = random_crop
self.out_h, self.out_w = output_size
self.pairs = pd.read_csv(csv_file)
if dataset_size is not None:
dataset_size = min(dataset_size, len(self.pairs))
self.pairs = self.pairs.iloc[0:dataset_size, :]
self.category = self.pairs.iloc[:, 2].as_matrix().astype('float')
if category is not None:
cat_idx = np.nonzero(self.category == category)[0]
self.category = self.category[cat_idx]
self.pairs = self.pairs.iloc[cat_idx, :]
self.img_A_names = self.pairs.iloc[:, 0]
self.img_B_names = self.pairs.iloc[:, 1]
self.point_A_coords = self.pairs.iloc[:, 3:5]
self.point_B_coords = self.pairs.iloc[:, 5:7]
self.flip = self.pairs.iloc[:, 7].as_matrix().astype('int')
self.dataset_path = dataset_path
self.transform = transform
# no cuda as dataset is called from CPU threads in dataloader and produces confilct
self.affineTnf = GeometricTnf(out_h=self.out_h,
out_w=self.out_w,
use_cuda=False)
""" Newly added """
self.theta_identity = torch.Tensor(
np.expand_dims(np.array([[1, 0, 0], [0, 1, 0]]),
0).astype(np.float32))
self.pointTnf = PointTnf(use_cuda=False)
def __init__(self,
transform='affine',
use_cuda=True):
super(TransLoss, self).__init__()
self.pointTnf = PointTnf(use_cuda=use_cuda)
self.transform = transform
self.coord = []
for i in range(config.NUM_OF_COORD):
for j in range(config.NUM_OF_COORD):
xx = []
xx.append(float(i))
xx.append(float(j))
self.coord.append(xx)
self.coord = np.expand_dims(np.array(self.coord).transpose(), axis=0)
self.coord = torch.from_numpy(self.coord).float()
if use_cuda:
self.coord = self.coord.cuda()
def pck_metric(batch,
batch_start_idx,
theta_aff,
theta_aff_tps,
stats,
args,
use_cuda=True):
alpha = args.pck_alpha
source_im_size = batch['source_im_size']
target_im_size = batch['target_im_size']
source_points = batch['source_points']
target_points = batch['target_points']
# Instantiate point transformer
pt = PointTnf(use_cuda=use_cuda, tps_reg_factor=args.tps_reg_factor)
# warp points with estimated transformations
target_points_norm = PointsToUnitCoords(target_points, target_im_size)
warped_points_aff_tps_norm = pt.tpsPointTnf(theta_aff_tps,
target_points_norm)
warped_points_aff_tps_norm = pt.affPointTnf(theta_aff,
warped_points_aff_tps_norm)
warped_points_aff_tps = PointsToPixelCoords(warped_points_aff_tps_norm,
source_im_size)
L_pck = batch['L_pck'].data
current_batch_size = batch['source_im_size'].size(0)
indices = range(batch_start_idx, batch_start_idx + current_batch_size)
pck_aff_tps = pck(source_points.data, warped_points_aff_tps.data, L_pck,
alpha)
stats['aff_tps']['pck'][indices] = pck_aff_tps.unsqueeze(1).cpu().numpy()
return stats
def __init__(self, csv_file, dataset_path, output_size=(240,240), transform=None, category=None):
self.category_names = ['car(G)', 'car(M)', 'car(S)', 'duck(S)',
'motorbike(G)', 'motorbike(M)', 'motorbike(S)',
'winebottle(M)', 'winebottle(wC)', 'winebottle(woC)']
self.out_h, self.out_w = output_size
self.pairs = pd.read_csv(csv_file)
self.category = self.pairs.iloc[:,2].as_matrix().astype('float')
if category is not None:
cat_idx = np.nonzero(self.category==category)[0]
self.category=self.category[cat_idx]
self.pairs=self.pairs.iloc[cat_idx,:]
self.img_A_names = self.pairs.iloc[:,0]
self.img_B_names = self.pairs.iloc[:,1]
self.point_A_coords = self.pairs.iloc[:, 3:5]
self.point_B_coords = self.pairs.iloc[:, 5:7]
self.flip = self.pairs.iloc[:,7].as_matrix().astype('int')
self.dataset_path = dataset_path
self.transform = transform
# no cuda as dataset is called from CPU threads in dataloader and produces confilct
self.affineTnf = GeometricTnf(out_h=self.out_h, out_w=self.out_w, use_cuda=False)
""" Newly added """
self.theta_identity = torch.Tensor(np.expand_dims(np.array([[1,0,0],[0,1,0]]),0).astype(np.float32))
self.pointTnf = PointTnf(use_cuda=False)
def area_metrics(batch,
batch_start_idx,
theta_aff,
theta_tps,
theta_aff_tps,
stats,
args,
use_cuda=True):
do_aff = theta_aff is not None
do_tps = theta_tps is not None
do_aff_tps = theta_aff_tps is not None
batch_size = batch['source_im_size'].size(0)
pt = PointTnf(use_cuda=use_cuda)
for b in range(batch_size):
h_src = int(batch['source_im_size'][b, 0].data.cpu().numpy())
w_src = int(batch['source_im_size'][b, 1].data.cpu().numpy())
h_tgt = int(batch['target_im_size'][b, 0].data.cpu().numpy())
w_tgt = int(batch['target_im_size'][b, 1].data.cpu().numpy())
target_mask_np, target_mask = poly_str_to_mask(
batch['target_polygon'][0][b],
batch['target_polygon'][1][b],
h_tgt,
w_tgt,
use_cuda=use_cuda)
source_mask_np, source_mask = poly_str_to_mask(
batch['source_polygon'][0][b],
batch['source_polygon'][1][b],
h_src,
w_src,
use_cuda=use_cuda)
grid_X, grid_Y = np.meshgrid(np.linspace(-1, 1, w_tgt),
np.linspace(-1, 1, h_tgt))
grid_X = torch.FloatTensor(grid_X).unsqueeze(0).unsqueeze(3)
grid_Y = torch.FloatTensor(grid_Y).unsqueeze(0).unsqueeze(3)
grid_X = Variable(grid_X, requires_grad=False)
grid_Y = Variable(grid_Y, requires_grad=False)
if use_cuda:
grid_X = grid_X.cuda()
grid_Y = grid_Y.cuda()
grid_X_vec = grid_X.view(1, 1, -1)
grid_Y_vec = grid_Y.view(1, 1, -1)
grid_XY_vec = torch.cat((grid_X_vec, grid_Y_vec), 1)
def pointsToGrid(x, h_tgt=h_tgt, w_tgt=w_tgt):
return x.contiguous().view(1, 2, h_tgt,
w_tgt).transpose(1, 2).transpose(2, 3)
idx = batch_start_idx + b
if do_aff:
grid_aff = pointsToGrid(
pt.affPointTnf(theta_aff[b, :].unsqueeze(0), grid_XY_vec))
warped_mask_aff = F.grid_sample(source_mask,
grid_aff,
align_corners=True)
flow_aff = th_sampling_grid_to_np_flow(source_grid=grid_aff,
h_src=h_src,
w_src=w_src)
stats['aff']['intersection_over_union'][
idx] = intersection_over_union(warped_mask_aff, target_mask)
stats['aff']['label_transfer_accuracy'][
idx] = label_transfer_accuracy(warped_mask_aff, target_mask)
stats['aff']['localization_error'][idx] = localization_error(
source_mask_np, target_mask_np, flow_aff)
if do_tps:
grid_tps = pointsToGrid(
pt.tpsPointTnf(theta_tps[b, :].unsqueeze(0), grid_XY_vec))
warped_mask_tps = F.grid_sample(source_mask,
grid_tps,
align_corners=True)
flow_tps = th_sampling_grid_to_np_flow(source_grid=grid_tps,
h_src=h_src,
w_src=w_src)
stats['tps']['intersection_over_union'][
idx] = intersection_over_union(warped_mask_tps, target_mask)
stats['tps']['label_transfer_accuracy'][
idx] = label_transfer_accuracy(warped_mask_tps, target_mask)
stats['tps']['localization_error'][idx] = localization_error(
source_mask_np, target_mask_np, flow_tps)
if do_aff_tps:
grid_aff_tps = pointsToGrid(
pt.affPointTnf(
theta_aff[b, :].unsqueeze(0),
pt.tpsPointTnf(theta_aff_tps[b, :].unsqueeze(0),
grid_XY_vec)))
warped_mask_aff_tps = F.grid_sample(source_mask,
grid_aff_tps,
align_corners=True)
flow_aff_tps = th_sampling_grid_to_np_flow(
source_grid=grid_aff_tps, h_src=h_src, w_src=w_src)
stats['aff_tps']['intersection_over_union'][
idx] = intersection_over_union(warped_mask_aff_tps,
target_mask)
stats['aff_tps']['label_transfer_accuracy'][
idx] = label_transfer_accuracy(warped_mask_aff_tps,
target_mask)
stats['aff_tps']['localization_error'][idx] = localization_error(
source_mask_np, target_mask_np, flow_aff_tps)
return stats
def area_metrics(batch,batch_start_idx,theta_1,theta_2,geometric_model_1,geometric_model_2,stats,args,use_cuda=True):
two_stage=(geometric_model_2 is not None)
pt=PointTnf(use_cuda=use_cuda)
if geometric_model_1=='affine':
tnf_1 = pt.affPointTnf
elif geometric_model_1=='hom':
tnf_1 = pt.homPointTnf
elif geometric_model_1=='tps':
tnf_1 = pt.tpsPointTnf
if two_stage:
if geometric_model_2=='affine':
tnf_2 = pt.affPointTnf
elif geometric_model_2=='hom':
tnf_2 = pt.homPointTnf
elif geometric_model_2=='tps':
tnf_2 = pt.tpsPointTnf
batch_size=batch['source_im_size'].size(0)
for b in range(batch_size):
h_src = int(batch['source_im_size'][b,0].data.cpu().numpy())
w_src = int(batch['source_im_size'][b,1].data.cpu().numpy())
h_tgt = int(batch['target_im_size'][b,0].data.cpu().numpy())
w_tgt = int(batch['target_im_size'][b,1].data.cpu().numpy())
target_mask_np,target_mask = poly_str_to_mask(batch['target_polygon'][0][b],
batch['target_polygon'][1][b],
h_tgt,w_tgt,use_cuda=use_cuda)
source_mask_np,source_mask = poly_str_to_mask(batch['source_polygon'][0][b],
batch['source_polygon'][1][b],
h_src,w_src,use_cuda=use_cuda)
grid_X,grid_Y = np.meshgrid(np.linspace(-1,1,w_tgt),np.linspace(-1,1,h_tgt))
grid_X = torch.FloatTensor(grid_X).unsqueeze(0).unsqueeze(3)
grid_Y = torch.FloatTensor(grid_Y).unsqueeze(0).unsqueeze(3)
grid_X = Variable(grid_X,requires_grad=False)
grid_Y = Variable(grid_Y,requires_grad=False)
if use_cuda:
grid_X = grid_X.cuda()
grid_Y = grid_Y.cuda()
grid_X_vec = grid_X.view(1,1,-1)
grid_Y_vec = grid_Y.view(1,1,-1)
grid_XY_vec = torch.cat((grid_X_vec,grid_Y_vec),1)
def pointsToGrid (x,h_tgt=h_tgt,w_tgt=w_tgt): return x.contiguous().view(1,2,h_tgt,w_tgt).transpose(1,2).transpose(2,3)
idx = batch_start_idx+b
# stage 1
grid_1 = pointsToGrid(tnf_1(theta_1[b,:].unsqueeze(0),grid_XY_vec))
warped_mask_1 = F.grid_sample(source_mask, grid_1, align_corners=True)
flow_1 = th_sampling_grid_to_np_flow(source_grid=grid_1,h_src=h_src,w_src=w_src)
stats[geometric_model_1]['intersection_over_union'][idx] = intersection_over_union(warped_mask_1,target_mask).cpu().numpy()
stats[geometric_model_1]['label_transfer_accuracy'][idx] = label_transfer_accuracy(warped_mask_1,target_mask).cpu().numpy()
stats[geometric_model_1]['localization_error'][idx] = localization_error(source_mask_np, target_mask_np, flow_1)
if two_stage:
grid_1_2 = pointsToGrid(tnf_1(theta_1[b,:].unsqueeze(0),tnf_2(theta_2[b,:].unsqueeze(0),grid_XY_vec)))
warped_mask_1_2 = F.grid_sample(source_mask, grid_1_2, align_corners=True)
flow_1_2 = th_sampling_grid_to_np_flow(source_grid=grid_1_2,h_src=h_src,w_src=w_src)
stats[geometric_model_1+'_'+geometric_model_2]['intersection_over_union'][idx] = intersection_over_union(warped_mask_1_2,target_mask).cpu().numpy()
stats[geometric_model_1+'_'+geometric_model_2]['label_transfer_accuracy'][idx] = label_transfer_accuracy(warped_mask_1_2,target_mask).cpu().numpy()
stats[geometric_model_1+'_'+geometric_model_2]['localization_error'][idx] = localization_error(source_mask_np, target_mask_np, flow_1_2)
return stats