def HessAffNetHardNet_DetectAndDescribe(img, Nfeatures=500):
var_image = torch.autograd.Variable(torch.from_numpy(img.astype(
np.float32)),
volatile=True)
var_image_reshape = var_image.view(1, 1, var_image.size(0),
var_image.size(1))
HessianAffine = ScaleSpaceAffinePatchExtractor(mrSize=5.192,
num_features=Nfeatures,
border=5,
num_Baum_iters=1,
AffNet=AffNetPix)
if USE_CUDA:
HessianAffine = HessianAffine.cuda()
var_image_reshape = var_image_reshape.cuda()
with torch.no_grad():
LAFs, responses = HessianAffine(var_image_reshape, do_ori=True)
patches = HessianAffine.extract_patches_from_pyr(LAFs, PS=32)
descriptors = HardNetDescriptor(patches)
# these are my affine maps to work with
Alist = convertLAFs_to_A23format(LAFs).cpu().numpy().astype(np.float32)
KPlist = [
cv2.KeyPoint(x=A[0, 2],
y=A[1, 2],
_size=10,
_angle=0.0,
_response=1,
_octave=packSIFTOctave(0, 0),
_class_id=1) for A in Alist
]
return KPlist, patches, descriptors, Alist, responses
def AffNetHardNet_describeFromKeys(img_np, KPlist):
img = torch.autograd.Variable(torch.from_numpy(img_np.astype(np.float32)),
volatile=True)
img = img.view(1, 1, img.size(0), img.size(1))
HessianAffine = ScaleSpaceAffinePatchExtractor(mrSize=5.192,
num_features=0,
border=0,
num_Baum_iters=0)
if USE_CUDA:
HessianAffine = HessianAffine.cuda()
img = img.cuda()
with torch.no_grad():
HessianAffine.createScaleSpace(
img) # to generate scale pyramids and stuff
descriptors = []
Alist = []
n = 0
# for patch_np in patches:
for kp in KPlist:
x, y = np.float32(kp.pt)
LAFs = normalizeLAFs(
torch.tensor([[AffNetPix.PS / 2, 0, x], [0, AffNetPix.PS / 2,
y]]).reshape(1, 2, 3),
img.size(3), img.size(2))
with torch.no_grad():
patch = HessianAffine.extract_patches_from_pyr(denormalizeLAFs(
LAFs, img.size(3), img.size(2)),
PS=AffNetPix.PS)
if WRITE_IMGS_DEBUG:
SaveImageWithKeys(patch.detach().cpu().numpy().reshape([32, 32]),
[], 'p2/' + str(n) + '.png')
if USE_CUDA:
# or ---> A = AffNetPix(subpatches.cuda()).cpu()
with torch.no_grad():
A = batched_forward(AffNetPix, patch.cuda(), 256).cpu()
else:
with torch.no_grad():
A = AffNetPix(patch)
new_LAFs = torch.cat([torch.bmm(A, LAFs[:, :, 0:2]), LAFs[:, :, 2:]],
dim=2)
dLAFs = denormalizeLAFs(new_LAFs, img.size(3), img.size(2))
with torch.no_grad():
patchaff = HessianAffine.extract_patches_from_pyr(dLAFs, PS=32)
if WRITE_IMGS_DEBUG:
SaveImageWithKeys(
patchaff.detach().cpu().numpy().reshape([32, 32]), [],
'p1/' + str(n) + '.png')
SaveImageWithKeys(img_np, [kp], 'im1/' + str(n) + '.png')
descriptors.append(
HardNetDescriptor(patchaff).cpu().numpy().astype(np.float32))
Alist.append(
convertLAFs_to_A23format(LAFs.detach().cpu().numpy().astype(
np.float32)))
n = n + 1
return descriptors, Alist
def test(model,epoch):
torch.cuda.empty_cache()
# switch to evaluate mode
model.eval()
from architectures import AffNetFast
affnet = AffNetFast()
model_weights = 'pretrained/AffNet.pth'
hncheckpoint = torch.load(model_weights)
affnet.load_state_dict(hncheckpoint['state_dict'])
affnet.eval()
detector = ScaleSpaceAffinePatchExtractor( mrSize = 5.192, num_features = 3000,
border = 5, num_Baum_iters = 1,
AffNet = affnet, OriNet = model)
descriptor = HardNet()
model_weights = 'HardNet++.pth'
hncheckpoint = torch.load(model_weights)
descriptor.load_state_dict(hncheckpoint['state_dict'])
descriptor.eval()
if args.cuda:
detector = detector.cuda()
descriptor = descriptor.cuda()
input_img_fname1 = 'test-graf/img1.png'#sys.argv[1]
input_img_fname2 = 'test-graf/img6.png'#sys.argv[1]
H_fname = 'test-graf/H1to6p'#sys.argv[1]
output_img_fname = 'graf_match.png'#sys.argv[3]
img1 = load_grayscale_var(input_img_fname1)
img2 = load_grayscale_var(input_img_fname2)
H = np.loadtxt(H_fname)
H1to2 = Variable(torch.from_numpy(H).float())
SNN_threshold = 0.8
with torch.no_grad():
LAFs1, descriptors1 = get_geometry_and_descriptors(img1, detector, descriptor)
torch.cuda.empty_cache()
LAFs2, descriptors2 = get_geometry_and_descriptors(img2, detector, descriptor)
visualize_LAFs(img1.detach().cpu().numpy().squeeze(), LAFs1.detach().cpu().numpy().squeeze(), 'b', show = False, save_to = LOG_DIR + "/detections1_" + str(epoch) + '.png')
visualize_LAFs(img2.detach().cpu().numpy().squeeze(), LAFs2.detach().cpu().numpy().squeeze(), 'g', show = False, save_to = LOG_DIR + "/detection2_" + str(epoch) + '.png')
dist_matrix = distance_matrix_vector(descriptors1, descriptors2)
min_dist, idxs_in_2 = torch.min(dist_matrix,1)
dist_matrix[:,idxs_in_2] = 100000;# mask out nearest neighbour to find second nearest
min_2nd_dist, idxs_2nd_in_2 = torch.min(dist_matrix,1)
mask = (min_dist / (min_2nd_dist + 1e-8)) <= SNN_threshold
tent_matches_in_1 = indxs_in1 = torch.autograd.Variable(torch.arange(0, idxs_in_2.size(0)), requires_grad = False).cuda()[mask]
tent_matches_in_2 = idxs_in_2[mask]
tent_matches_in_1 = tent_matches_in_1.long()
tent_matches_in_2 = tent_matches_in_2.long()
LAF1s_tent = LAFs1[tent_matches_in_1,:,:]
LAF2s_tent = LAFs2[tent_matches_in_2,:,:]
min_dist, plain_indxs_in1, idxs_in_2 = get_GT_correspondence_indexes(LAF1s_tent, LAF2s_tent,H1to2.cuda(), dist_threshold = 6)
plain_indxs_in1 = plain_indxs_in1.long()
inl_ratio = float(plain_indxs_in1.size(0)) / float(tent_matches_in_1.size(0))
print 'Test epoch', str(epoch)
print 'Test on graf1-6,', tent_matches_in_1.size(0), 'tentatives', plain_indxs_in1.size(0), 'true matches', str(inl_ratio)[:5], ' inl.ratio'
visualize_LAFs(img1.detach().cpu().numpy().squeeze(), LAF1s_tent[plain_indxs_in1.long(),:,:].detach().cpu().numpy().squeeze(), 'g', show = False, save_to = LOG_DIR + "/inliers1_" + str(epoch) + '.png')
visualize_LAFs(img2.detach().cpu().numpy().squeeze(), LAF2s_tent[idxs_in_2.long(),:,:].detach().cpu().numpy().squeeze(), 'g', show = False, save_to = LOG_DIR + "/inliers2_" + str(epoch) + '.png')
return
img = np.mean(np.array(img), axis=2)
var_image = torch.autograd.Variable(torch.from_numpy(img.astype(np.float32)),
volatile=True)
var_image_reshape = var_image.view(1, 1, var_image.size(0), var_image.size(1))
AffNetPix = AffNetFast(PS=32)
weightd_fname = '../../pretrained/AffNet.pth'
checkpoint = torch.load(weightd_fname)
AffNetPix.load_state_dict(checkpoint['state_dict'])
AffNetPix.eval()
HA = ScaleSpaceAffinePatchExtractor(mrSize=5.192,
num_features=nfeats,
border=5,
num_Baum_iters=1,
th=th,
AffNet=AffNetPix)
if USE_CUDA:
HA = HA.cuda()
var_image_reshape = var_image_reshape.cuda()
with torch.no_grad():
LAFs, resp = HA(var_image_reshape)
ells = LAFs2ell(LAFs.data.cpu().numpy())
np.savetxt(output_fname, ells, delimiter=' ', fmt='%10.10f')
line_prepender(output_fname, str(len(ells)))
line_prepender(output_fname, '1.0')
d4 = nn.Sequential(d4, L2Norm())
desc_list = [d1, d2, d3, d4]
desc_names = ['Pixels', 'HardNet', 'SIFT', 'TFeat']
USE_CUDA = False
detector = ScaleSpaceAffinePatchExtractor(mrSize=5.12,
num_features=200,
border=32,
num_Baum_iters=0)
descriptor = HardNet()
model_weights = '../../HardNet++.pth'
hncheckpoint = torch.load(model_weights)
descriptor.load_state_dict(hncheckpoint['state_dict'])
descriptor.eval()
if USE_CUDA:
detector = detector.cuda()
descriptor = descriptor.cuda()
def get_geometry(img, det):
with torch.no_grad():
LAFs, resp = det(img)
return LAFs #, descriptors
#visualize_LAFs(img1.cpu().numpy().squeeze(), L3.cpu().numpy().squeeze(), 'g')
#LOP.optimize(L1, L2, img1, img2, n_iters = 200);
#LOP.savemp4_per_desc('test.mp4')
from Losses import loss_HardNet