data = Info.ReadReconstructionData(info)
trajectory = {}
for shot in data['shots']:
[x, y, z] = optical_center(data['shots'][shot])
trajectory[shot] = [x, y, z]
data['gcp'] = gcp
#print gcp
data['transformation'] = list(M)
#print type(M[0])
data['trajectory'] = trajectory
#print trajectory
f_name = Info.Get3DRansacFileName(info)
f = open(f_name, 'w')
f.write(json.dumps(data, indent=4))
f.close()
print '%s ransac finish' % ID
if __name__ == '__main__':
do_lst = Info.GetStateList(['ransac_2D', 'match_result'], ['yes', 'yes'])
print do_lst
print len(do_lst)
#pool= Pool(processes = 8)
#pool.map(RPE.RansacPointExtract, do_lst)
#for one in do_lst:
#RunRansac(one)
#pool.map(RunRansac, do_lst)
#SendEmail.SendEmail()
RunExtract('000067')
RunRansac('000067')
WriteImageList(frame_path, frame_lst_name)
WriteImageList(pano_download_path, pano_lst_name)
command_1 = 'VisualSFM siftgpu %s' % frame_lst_name
command_2 = 'VisualSFM siftgpu %s' % pano_lst_name
subprocess.call(command_1, shell=True)
subprocess.call(command_2, shell=True)
command_1 = 'mv %s/*.sift %s' % (frame_path, frame_sift_path)
command_2 = 'mv %s/*.sift %s' % (pano_download_path, pano_sift_path)
subprocess.call(command_1, shell=True)
subprocess.call(command_2, shell=True)
GetSiftList(frame_sift_path, frame_sift_lst_name)
GetSiftList(pano_sift_path, pano_sift_lst_name)
os.remove(frame_lst_name)
os.remove(pano_lst_name)
if __name__ == '__main__':
do_lst = Info.GetStateList(
['reconstruction', 'downloadpano', 'extractsift'],
['yes', 'yes', 'no'])
print 'Total %d videos to extract sift' % len(do_lst)
#pool = Pool(processes = 1)
#pool.map(ExtractSift, do_lst)
for ID in do_lst:
ExtractSift(ID)
#exit()
SendEmail.SendEmail(Text='ExtractSift finish!!')
if len(reconstruct_set) == 0 or len(latlon_set) == 0:
return
#try:
[M, model] = RANSAC_2D(reconstruct_set,
latlon_set,
iteration=1000,
tolerance=Info.Config.STEP_TEN_METER)
print M
#except:
# return
if not M is None and not model is None:
reconstruct = Info.ReadReconstructionData(info)['shots']
f = open(Info.GetGCPFileName(info), 'w')
frame_lst = sorted(reconstruct.keys())
for index, frame in enumerate(frame_lst):
[x, y, z] = optical_center(reconstruct[frame])
point = np.dot(M,
np.transpose(np.array([x, y, 1], dtype=np.float32)))
s = '%s\t%f\t%f\n' % (frame, point[0], point[1])
f.write(s)
f.close()
if __name__ == '__main__':
do_lst = Info.GetStateList(['matchLst'], ['yes'])
#pool = Pool(processes = 8)
RunRANSAC('001234')
#pool.map(RunRANSAC, do_lst)
#SendEmail.SendEmail(Text = 'RANSAC finish!!!')
#print do_lst
except:
data.pop(key)
continue
#print panoid
if panoid is None:
data.pop(key)
continue
elif not panoid in pano_lst:
pano_lst.append(panoid)
try:
loc = GSV.getLocationbyID(panoid)
data[key] = [float(loc[0]), float(loc[1])]
except:
data.pop(key)
continue
else:
data.pop(key)
f = open(info['match_path'] + '/google_info.json', 'w')
f.write(json.dumps(data, indent=4))
f.close()
if __name__ == '__main__':
do_lst = Info.GetStateList(['lat_lon'], ['yes'])
#print do_lst
#print len(do_lst)
Merge('000067')
#for one in do_lst:
# Merge(one)
#SendEmail.SendEmail()
def Plot():
lst = Info.GetStateList(['match_result'], ['yes'])
do_lst = [x for x in lst if CheckState(x)]
#print len(do_lst)
# our
our_dis = []
for one in do_lst:
info = Info.GetVideoInfo(one)
f = GetOurPath(info)
data = LoadFile(f)
for key in data:
our_dis.append(data[key])
number_of_point = len(our_dis)
our_dis = np.array(our_dis, dtype=np.float32)
print 'Ourmethod Max val : %f' % np.max(our_dis)
print 'Ourmethod Min val : %f' % np.min(our_dis)
print 'Ourmethod Mean val : %f' % np.mean(our_dis)
print 'Ourmethod Standard Deviation : %f' % np.std(our_dis)
top_bound = np.ceil(np.max(our_dis))
#print top_bound
histogram = np.zeros([int(top_bound) + 1], dtype=np.float32)
ceil_data = np.ceil(our_dis)
for i in range(0, int(top_bound) + 1):
count = np.sum(ceil_data <= i)
histogram[i] = count
#print histogram
our_Y = histogram
our_X = np.arange(0, top_bound + 1)
# affine
affine_dis = []
for one in do_lst:
info = Info.GetVideoInfo(one)
f = GetAffinePath(info)
data = LoadFile(f)
for key in data:
affine_dis.append(data[key])
affine_dis = np.array(affine_dis, dtype=np.float32)
print 'Affine Max val : %f' % np.max(affine_dis)
print 'Affine Min val : %f' % np.min(affine_dis)
print 'Affine Mean val : %f' % np.mean(affine_dis)
print 'Affine Standard Deviation : %f' % np.std(affine_dis)
top_bound = np.ceil(np.max(affine_dis))
#print top_bound
histogram = np.zeros([int(top_bound) + 1], dtype=np.float32)
ceil_data = np.ceil(affine_dis)
for i in range(0, int(top_bound) + 1):
count = np.sum(ceil_data <= i)
histogram[i] = count
#print histogram
affine_Y = histogram
affine_X = np.arange(0, top_bound + 1)
# rigid
rigid_dis = []
for one in do_lst:
info = Info.GetVideoInfo(one)
f = GetRigidPath(info)
data = LoadFile(f)
for key in data:
rigid_dis.append(data[key])
rigid_dis = np.array(rigid_dis, dtype=np.float32)
print 'Rigid Max val : %f' % np.max(rigid_dis)
print 'Rigid Min val : %f' % np.min(rigid_dis)
print 'Rigid Mean val : %f' % np.mean(rigid_dis)
print 'Rigid Standard Deviation : %f' % np.std(rigid_dis)
top_bound = np.ceil(np.max(rigid_dis))
#print top_bound
histogram = np.zeros([int(top_bound) + 1], dtype=np.float32)
ceil_data = np.ceil(rigid_dis)
for i in range(0, int(top_bound) + 1):
count = np.sum(ceil_data <= i)
histogram[i] = count
#print histogram
rigid_Y = histogram
rigid_X = np.arange(0, top_bound + 1)
our_max = np.max(our_Y)
affine_max = np.max(affine_Y)
rigid_max = np.max(rigid_Y)
all_max = np.max([our_max, affine_max, rigid_max])
top_bound = int(np.ceil(all_max))
X_axis = np.arange(0, top_bound + 1)
tmp = np.zeros([top_bound + 1], dtype=np.float32)
tmp[:] = our_max
tmp[0:our_Y.size] = our_Y
our_Y = tmp / number_of_point * 100
tmp = np.zeros([top_bound + 1], dtype=np.float32)
tmp[:] = affine_max
tmp[0:affine_Y.size] = affine_Y
affine_Y = tmp / number_of_point * 100
tmp = np.zeros([top_bound + 1], dtype=np.float32)
tmp[:] = rigid_max
tmp[0:rigid_Y.size] = rigid_Y
rigid_Y = tmp / number_of_point * 100
X_axis = X_axis[1:]
our_Y = our_Y[1:]
affine_Y = affine_Y[1:]
rigid_Y = rigid_Y[1:]
fig = plt.subplot('111')
plt.plot(X_axis, our_Y, 'r', color='r', linewidth=4, label='ourmethod')
plt.plot(X_axis, affine_Y, 'r', color='g', linewidth=4, label='affine')
plt.plot(X_axis, rigid_Y, 'r', color='b', linewidth=4, label='rigid')
plt.xscale('log')
#plt.xlim([1, 300])
plt.xlabel('within distance(m)')
plt.ylabel('persent(%)')
plt.legend(loc='right')
plt.savefig('ransac_transform.jpg')
plt.show()
frame_short_name = name.split('.')[0]
for i in range(0,results.shape[1]):
pano_name = pano_sift_lst[results[index, i]]
pano_short_name = pano_name.split('.')[0]
kp_pairs = lib_SIFTmatch.flann_match('%s/%s'%(info['frame_sift_path'],frame_short_name),
'%s/%s'%(info['pano_sift_path'],pano_short_name))
#print kp_pairs
try:
(mkp1, mkp2) = zip(*kp_pairs)
mkp1_pts = [ (x[0],x[1]) for x in mkp1 ]
mkp2_pts = [ (x[0],x[1]) for x in mkp2 ]
mkp1_pts = np.float32(mkp1_pts)
mkp2_pts = np.float32(mkp2_pts)
F, mask = cv2.findFundamentalMat(mkp1_pts,mkp2_pts,cv2.FM_RANSAC,20)
q_pts = mkp1_pts[mask.ravel()==1]
t_pts = mkp2_pts[mask.ravel()==1]
Mi.append(len(q_pts))
except:
Mi.append(0)
continue
MM.append(Mi)
np.save('%s/results_fundM'%info['pano_path'],MM)
if __name__ == '__main__':
do_lst = Info.GetStateList(['fisher', 'matchFunM'], ['yes', 'no'])
#print do_lst
#MatchFunM(do_lst[0])
pool = Pool(processes = 8)
pool.map(MatchFunM, do_lst)
SendEmail.SendEmail(Text = 'Match Finish')
gmm = (data['a'], data['b'], data['c'])
mean = data['mean']
pca_transform = data['pca_transform']
image_fvs = []
for image_dec in (frame_desc + pano_desc):
image_dec = np.dot(image_dec - mean, pca_transform)
fv = ynumpy.fisher(gmm, image_dec, include='mu')
image_fvs.append(fv)
image_fvs = np.vstack(image_fvs)
image_fvs = np.sign(image_fvs) * np.abs(image_fvs)**0.5
norms = np.sqrt(np.sum(image_fvs**2, 1))
image_fvs /= norms.reshape(-1, 1)
image_fvs[np.isnan(image_fvs)] = 100
frame_fvs = image_fvs[0:len(frame_sift_lst)]
pano_fvs = image_fvs[len(frame_sift_lst):]
results, distances = ynumpy.knn(frame_fvs, pano_fvs, nnn=10)
#print results
#print distances
np.save(info['pano_path'] + '/fisher_results', results)
if __name__ == '__main__':
do_lst = Info.GetStateList(['extractsift', 'fisher'], ['yes', 'no'])
#print do_lst
pool = Pool(processes=4)
pool.map(GetKnn, do_lst)
SendEmail.SendEmail(Text='Fisher Finish!!!')
import SendEmail
def Merge(ID):
info = Info.GetVideoInfo(ID)
f1_name = Info.Get3DRansacFileName(info)
subprocess.call('cp %s %s/ransac_3D_result_old.json' %
(f1_name, info['match_path']),
shell=True)
f2_name = info['match_path'] + '/timeline.json'
f1 = open(f1_name, 'r')
f2 = open(f2_name, 'r')
data = json.load(f1)
tim = json.load(f2)
data['id'] = tim['id']
data['time'] = tim['time']
f1.close()
f2.close()
f1 = open(f1_name, 'w')
f1.write(json.dumps(data, indent=4))
f1.close()
if __name__ == '__main__':
#Merge('000049')
do_lst = Info.GetStateList(['ransac_3D'], ['yes'])
print(do_lst)
Merge('000067')
#pool = Pool(processes = 4)
#pool.map(Merge, do_lst)
for frame_index, frame_sift_name in enumerate(frame_sift_lst):
arg_sort_index = np.argsort(match_score[frame_index, :])
highest_index = arg_sort_index[-1]
highest_score = match_score[frame_index, highest_index]
second_index = arg_sort_index[-2]
second_score = match_score[frame_index, second_index]
ratio = float(highest_score) / float(second_score)
if highest_score >= THRESHOLD:
frame_name = frame_sift_name.split('.')[0] + '.jpg'
pano_sift_name = pano_sift_lst[fisher_result[frame_index,
highest_index]]
pano_name = pano_sift_name.split('.')[0] + '.jpg'
pano_id = pano_name[5:27]
print pano_id
loc = GoogleSV.getLocationbyID(pano_id)
if loc is None:
continue
s = '%s\t%s\t%s\t%s\t%d\n' % (frame_name, pano_name, loc[0],
loc[1], highest_score)
f.write(s)
f.close()
if __name__ == '__main__':
do_lst = Info.GetStateList(['matchFunM'], ['yes'])
GetResultLst('000225') #000538
#pool = Pool(processes = 2)
#pool.map(GetResultLst, do_lst)
def Plot():
lst = Info.GetStateList(['match_result'], ['yes'])
do_lst = []
for one in lst:
if CheckState(one):
do_lst.append(one)
# Deep
dis_data = []
for one in do_lst:
info = Info.GetVideoInfo(one)
f = GetDeepPath(info)
data = LoadFile(f)
for key in data:
dis_data.append(data[key])
deep_dis_data = np.array(dis_data, dtype=np.float32)
print 'Deep Max val : %f'%np.max(deep_dis_data)
print 'Deep Min val : %f'%np.min(deep_dis_data)
print 'Deep Mean val : %f'%np.mean(deep_dis_data)
print 'Deep Standard Deviation : %f'%np.std(deep_dis_data)
deep_max = int(np.max(dis_data))
nop = len(deep_dis_data)
#####
# Hog
dis_data = []
for one in do_lst:
info = Info.GetVideoInfo(one)
f = GetHogPath(info)
data = LoadFile(f)
for key in data:
dis_data.append(data[key])
hog_dis_data = np.array(dis_data, dtype=np.float32)
print 'Hog Max val : %f'%np.max(hog_dis_data)
print 'Hog Min val : %f'%np.min(hog_dis_data)
print 'Hog Mean val : %f'%np.mean(hog_dis_data)
print 'Hog Standard Deviation : %f'%np.std(hog_dis_data)
hog_max = int(np.max(dis_data))
#####
# Dsift
dis_data = []
for one in do_lst:
info = Info.GetVideoInfo(one)
f = GetDsiftPath(info)
data = LoadFile(f)
for key in data:
dis_data.append(data[key])
dsift_dis_data = np.array(dis_data, dtype=np.float32)
print 'Dsift Max val : %f'%np.max(dsift_dis_data)
print 'Dsift Min val : %f'%np.min(dsift_dis_data)
print 'Dsift Mean val : %f'%np.mean(dsift_dis_data)
print 'Dsift Standard Deviation : %f'%np.std(dsift_dis_data)
dsift_max = int(np.max(dis_data))
#####
all_max = np.max([deep_max, hog_max, dsift_max])
top_bound = int(np.ceil(all_max))
x_axis = np.arange(0, top_bound+1)
deep_hist = np.zeros([top_bound+1], dtype=np.float32)
hog_hist = np.zeros([top_bound+1], dtype=np.float32)
dsift_hist = np.zeros([top_bound+1], dtype=np.float32)
for i in range(0, top_bound+1):
deep_hist[i] = np.sum(deep_dis_data <= i)
hog_hist[i] = np.sum(hog_dis_data <= i)
dsift_hist[i] = np.sum(dsift_dis_data <= i)
x_axis = x_axis[1:]
deep_hist = deep_hist[1:]
hog_hist = hog_hist[1:]
dsift_hist = dsift_hist[1:]
plt.subplot('111')
plt.plot(x_axis, deep_hist/nop*100, 'r', color='r', linewidth='4', label = 'deep match')
plt.plot(x_axis, hog_hist/nop*100, 'r', color='g', linewidth='4', label = 'hog match')
plt.plot(x_axis, dsift_hist/nop*100, 'r', color='b', linewidth='4', label = 'dense sift match')
plt.xscale('log')
#plt.xscale('log')
#plt.xlim([1])
plt.xlabel('within distance(m)')
plt.ylabel('persent(%)')
plt.legend(loc = 'right')
plt.savefig('match.jpg')
plt.show()
