[pre]script for lightstage
This commit is contained in:
shuaiqing
parent
2e83642c7c
commit
7a80646902
552
scripts/dataset/pre_lightstage.py
Normal file
552
scripts/dataset/pre_lightstage.py
Normal file
@ -0,0 +1,552 @@
|
|||||||
|
import re
|
||||||
|
import numpy as np
|
||||||
|
import os, sys
|
||||||
|
import cv2
|
||||||
|
import shutil
|
||||||
|
from os.path import join
|
||||||
|
from tqdm import trange, tqdm
|
||||||
|
from multiprocessing import Pool
|
||||||
|
import json
|
||||||
|
|
||||||
|
def save_json(file, data):
|
||||||
|
if not os.path.exists(os.path.dirname(file)):
|
||||||
|
os.makedirs(os.path.dirname(file))
|
||||||
|
with open(file, 'w') as f:
|
||||||
|
json.dump(data, f, indent=4)
|
||||||
|
|
||||||
|
def parseImg(imgname):
|
||||||
|
""" 解析图像名称
|
||||||
|
|
||||||
|
Arguments:
|
||||||
|
imgname {str} --
|
||||||
|
|
||||||
|
Returns:
|
||||||
|
dic -- 包含文件图像信息的字典
|
||||||
|
"""
|
||||||
|
s = re.search(
|
||||||
|
'(?P<id>\d+)_(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})_(?P<hour>\d{2})-(?P<min>\d{2})-(?P<sec>\d{2})\.(?P<ms>\d{3})',
|
||||||
|
imgname)
|
||||||
|
assert s is not None, imgname
|
||||||
|
dic = s.groupdict()
|
||||||
|
for key in dic.keys():
|
||||||
|
dic[key] = int(dic[key])
|
||||||
|
dic['time'] = dic['ms'] + dic['sec'] * 1000 + dic['min'] * 60000 + dic['hour'] * 60000 * 60
|
||||||
|
return dic
|
||||||
|
|
||||||
|
|
||||||
|
def getCamNum(x):
|
||||||
|
return x.split('_B')[1]
|
||||||
|
|
||||||
|
|
||||||
|
def getImgId(x):
|
||||||
|
return x.split('_')[4]
|
||||||
|
|
||||||
|
|
||||||
|
def findBeginEnd(images_info):
|
||||||
|
begin_time = 0
|
||||||
|
end_time = np.inf
|
||||||
|
for key in images_info:
|
||||||
|
first_frame = images_info[key]['first_frame']
|
||||||
|
last_frame = images_info[key]['last_frame']
|
||||||
|
curr_f_time = images_info[key][first_frame]['time']
|
||||||
|
curr_e_time = images_info[key][last_frame]['time']
|
||||||
|
if curr_f_time > begin_time:
|
||||||
|
begin_time = curr_f_time
|
||||||
|
if curr_e_time < end_time:
|
||||||
|
end_time = curr_e_time
|
||||||
|
return begin_time, end_time
|
||||||
|
|
||||||
|
|
||||||
|
def findRef(images_info):
|
||||||
|
ref_cam = 0
|
||||||
|
min_frame = np.inf
|
||||||
|
|
||||||
|
for key in images_info:
|
||||||
|
first_frame = images_info[key]['first_frame']
|
||||||
|
last_frame = images_info[key]['last_frame']
|
||||||
|
f_id = images_info[key][first_frame]['id']
|
||||||
|
e_id = images_info[key][last_frame]['id']
|
||||||
|
if (e_id - f_id) < min_frame:
|
||||||
|
min_frame = e_id - f_id
|
||||||
|
ref_cam = key
|
||||||
|
return ref_cam
|
||||||
|
|
||||||
|
|
||||||
|
def findNearest(cam_info, time):
|
||||||
|
# 找time最接近的帧的名称
|
||||||
|
select_frame = ''
|
||||||
|
# WARN: 确保cam_info是有序的
|
||||||
|
img_pre = None
|
||||||
|
for idx, img in enumerate(cam_info.keys()):
|
||||||
|
if isinstance(cam_info[img], dict):
|
||||||
|
if cam_info[img]['time'] < time:
|
||||||
|
img_pre = img
|
||||||
|
continue
|
||||||
|
else:
|
||||||
|
select_frame = img
|
||||||
|
break
|
||||||
|
# 判断一下处于边界上的两帧，哪一帧的时间更接近
|
||||||
|
if img_pre is not None:
|
||||||
|
if abs(time - cam_info[img_pre]['time']) < abs(time - cam_info[img]['time']):
|
||||||
|
select_frame = img_pre
|
||||||
|
return select_frame
|
||||||
|
|
||||||
|
|
||||||
|
def get_filelists(path, save_path):
|
||||||
|
cameralists = sorted(os.listdir(path), key=lambda x: getCamNum(x))
|
||||||
|
images_info = {}
|
||||||
|
for camname in cameralists:
|
||||||
|
images_info[camname] = {}
|
||||||
|
imglists = listdir([path, camname])
|
||||||
|
imglists.sort(key=lambda x: getImgId(x))
|
||||||
|
for imgname in tqdm(imglists, desc=camname):
|
||||||
|
images_info[camname][imgname] = parseImg(imgname)
|
||||||
|
images_info[camname]['first_frame'] = imglists[0]
|
||||||
|
images_info[camname]['last_frame'] = imglists[-1]
|
||||||
|
# print(images_info[camname])
|
||||||
|
# 寻找最晚开始最早结束的时间
|
||||||
|
begin_time, end_time = findBeginEnd(images_info)
|
||||||
|
print('begin time: {}, end time: {}'.format(begin_time, end_time))
|
||||||
|
# 寻找帧率最低的视频，以这个视频为参考
|
||||||
|
if args.ref is None:
|
||||||
|
ref_cam = findRef(images_info)
|
||||||
|
else:
|
||||||
|
ref_cam = args.ref
|
||||||
|
|
||||||
|
print('The reference camera is {}'.format(ref_cam))
|
||||||
|
# 以帧率最低的相机为参考，对每一帧寻找其他相机时间最接近的帧
|
||||||
|
output_info = {key: [] for key in cameralists}
|
||||||
|
for imgname in tqdm(images_info[ref_cam].keys(), 'sync'):
|
||||||
|
if isinstance(images_info[ref_cam][imgname], dict):
|
||||||
|
cur_time = images_info[ref_cam][imgname]['time']
|
||||||
|
if cur_time < begin_time:
|
||||||
|
continue
|
||||||
|
if cur_time > end_time:
|
||||||
|
break
|
||||||
|
for cam in cameralists:
|
||||||
|
if cam == ref_cam:
|
||||||
|
select = imgname
|
||||||
|
else:
|
||||||
|
select = findNearest(images_info[cam], cur_time)
|
||||||
|
output_info[cam].append(select)
|
||||||
|
# 将图片保存
|
||||||
|
mkdir(save_path)
|
||||||
|
# 保存匹配信息
|
||||||
|
# TODO:增加匹配时间差的指标
|
||||||
|
import json
|
||||||
|
with open(join(save_path, 'match_info.json'), 'w') as f:
|
||||||
|
json.dump(output_info, f, indent=4)
|
||||||
|
for cam in cameralists:
|
||||||
|
mkdir(join(save_path, cam))
|
||||||
|
for i, imgname in enumerate(tqdm(output_info[cam], desc=cam)):
|
||||||
|
src = join(path, cam, imgname)
|
||||||
|
dst = join(save_path, cam, '%06d.jpg' % i)
|
||||||
|
img = cv2.imread(src)
|
||||||
|
if img.shape[0] == 2048:
|
||||||
|
img = cv2.resize(img, (1024, 1024), cv2.INTER_NEAREST)
|
||||||
|
cv2.imwrite(dst, img)
|
||||||
|
|
||||||
|
def getFileDict(path):
|
||||||
|
cams = sorted(os.listdir(path))
|
||||||
|
cams = [cam for cam in cams if os.path.isdir(join(path, cam))]
|
||||||
|
cams = list(filter(
|
||||||
|
lambda x:\
|
||||||
|
x.startswith('Camera')\
|
||||||
|
and x not in filter_list
|
||||||
|
, cams)) # B6相机同步有问题 不要使用了
|
||||||
|
results = {}
|
||||||
|
for cam in cams:
|
||||||
|
# 注意：lightstage的图像直接sort就是按照顺序了的
|
||||||
|
files = sorted(os.listdir(join(path, cam)))
|
||||||
|
files = [f for f in files if f.endswith('.jpg')]
|
||||||
|
results[cam] = files
|
||||||
|
return cams, results
|
||||||
|
|
||||||
|
def sync_by_name(imagelists, times_all, cams):
|
||||||
|
# 选择开始帧
|
||||||
|
start = max([t[0] for t in times_all.values()])
|
||||||
|
# 弹出开始帧以前的数据
|
||||||
|
for cam in cams:
|
||||||
|
times = times_all[cam].tolist()
|
||||||
|
while times[0] < start:
|
||||||
|
times.pop(0)
|
||||||
|
imagelists[cam].pop(0)
|
||||||
|
times_all[cam] = np.array(times)
|
||||||
|
# 选择参考视角的时候,应该选择与其他视角的距离最近的作为参考
|
||||||
|
best_distances = []
|
||||||
|
for cam in cams:
|
||||||
|
# 分别对每个进行设置, 使用第一帧的时间,留有余地
|
||||||
|
ref_time = times_all[cam][1]
|
||||||
|
distances = []
|
||||||
|
for c in cams:
|
||||||
|
dist = np.abs(times_all[c] - ref_time).min()
|
||||||
|
distances.append(dist)
|
||||||
|
print('{:10s}: {:.2f}'.format(cam, sum(distances)/len(cams)))
|
||||||
|
best_distances.append(sum(distances)/len(cams))
|
||||||
|
best_distances = np.array(best_distances)
|
||||||
|
ref_view = best_distances.argmin()
|
||||||
|
if args.ref is None:
|
||||||
|
ref_cam = cams[best_distances.argmin()]
|
||||||
|
else:
|
||||||
|
ref_cam = args.ref
|
||||||
|
ref_view = cams.index(ref_cam)
|
||||||
|
|
||||||
|
times_all = [times_all[cam] for cam in cams]
|
||||||
|
print('Select reference view: ', cams[ref_view])
|
||||||
|
if False:
|
||||||
|
distance = np.eye((dimGroups[-1]))
|
||||||
|
for nv0 in range(len(times_all)-1):
|
||||||
|
for nv1 in range(nv0+1, len(times_all)):
|
||||||
|
dist = np.abs(times_all[nv0][:, None] - times_all[nv1][None, :])
|
||||||
|
dist = (MAX_DIST - dist)/MAX_DIST
|
||||||
|
dist[dist<0] = 0
|
||||||
|
distance[dimGroups[nv0]:dimGroups[nv0+1], dimGroups[nv1]:dimGroups[nv1+1]] = dist
|
||||||
|
distance[dimGroups[nv1]:dimGroups[nv1+1], dimGroups[nv0]:dimGroups[nv0+1]] = dist.T
|
||||||
|
matched, ref_view = match_dtw(distance, dimGroups, debug=args.debug)
|
||||||
|
elif True:
|
||||||
|
# 使用最近邻选择
|
||||||
|
matched = []
|
||||||
|
for nv in range(len(times_all)):
|
||||||
|
dist = np.abs(times_all[ref_view][:, None] - times_all[nv][None, :])
|
||||||
|
rows = np.arange(dist.shape[0])
|
||||||
|
argmin0 = dist.argmin(axis=1)
|
||||||
|
# 直接选择最近的吧
|
||||||
|
# 去掉开头
|
||||||
|
for i in range(argmin0.shape[0]):
|
||||||
|
if argmin0[i] == argmin0[i+1]:
|
||||||
|
argmin0[i] = -1
|
||||||
|
else:
|
||||||
|
break
|
||||||
|
# 去掉结尾
|
||||||
|
for i in range(1, argmin0.shape[0]):
|
||||||
|
if argmin0[-i] == argmin0[-i-1]:
|
||||||
|
argmin0[-i] = -1
|
||||||
|
else:
|
||||||
|
break
|
||||||
|
matched.append(argmin0)
|
||||||
|
matched = np.stack(matched)
|
||||||
|
elif False:
|
||||||
|
# 1. 首先判断一下所有视角的最接近的点
|
||||||
|
nViews = len(times_all)
|
||||||
|
TIME_STEP = 20
|
||||||
|
REF_OFFSET = 20 # 给参考视角增加一个帧的偏移，保证所有相机都正常开启了，同时增加一个帧的结束，保证所有相机都结束了
|
||||||
|
views_ref = [ref_view]
|
||||||
|
matched = {
|
||||||
|
ref_view:np.arange(REF_OFFSET, times_all[ref_view].shape[0]-REF_OFFSET)
|
||||||
|
}
|
||||||
|
while True:
|
||||||
|
times_mean = np.stack([times_all[ref][matched[ref]] for ref in matched.keys()])
|
||||||
|
times_mean = np.mean(times_mean, axis=0)
|
||||||
|
infos = []
|
||||||
|
for nv in range(nViews):
|
||||||
|
if nv in matched.keys():
|
||||||
|
continue
|
||||||
|
if False:
|
||||||
|
dist_all = []
|
||||||
|
for ref, indices in matched.items():
|
||||||
|
dist = np.abs(times_all[ref][indices, None] - times_all[nv][None, :])
|
||||||
|
dist[dist>TIME_STEP] = 10*TIME_STEP
|
||||||
|
dist_all.append(dist)
|
||||||
|
dist = np.stack(dist_all).sum(axis=0)
|
||||||
|
dist = dist / len(matched.keys())
|
||||||
|
else:
|
||||||
|
dist = np.abs(times_mean[:, None] - times_all[nv][None, :])
|
||||||
|
argmin0 = dist.argmin(axis=1)
|
||||||
|
rows = np.arange(dist.shape[0])
|
||||||
|
dist_sum = dist.min(axis=1).mean()
|
||||||
|
infos.append({
|
||||||
|
'v': nv,
|
||||||
|
'dist_sum': dist_sum,
|
||||||
|
'argmin': argmin0
|
||||||
|
})
|
||||||
|
print(nv, dist_sum)
|
||||||
|
if len(infos) == 0:
|
||||||
|
break
|
||||||
|
infos.sort(key=lambda x:x['dist_sum'])
|
||||||
|
print('Select view: ', infos[0]['v'], infos[0]['dist_sum'])
|
||||||
|
matched[infos[0]['v']] = infos[0]['argmin']
|
||||||
|
matched = np.stack([matched[nv] for nv in range(nViews)])
|
||||||
|
else:
|
||||||
|
# 选择一个开头，计算最佳的偏移
|
||||||
|
# 开始帧：所有的开始帧中的最晚的一帧
|
||||||
|
# 假定恒定帧率，只需要选择一个开头就好了
|
||||||
|
nViews = len(times_all)
|
||||||
|
start_t = max([t[0] for t in times_all])
|
||||||
|
# 留出10帧来操作
|
||||||
|
start_f = [np.where(t>start_t)[0][0] + 10 for t in times_all]
|
||||||
|
start_t = times_all[ref_view][start_f[ref_view]]
|
||||||
|
valid_f = [[np.where(t<start_t)[0][-1],np.where(t>=start_t)[0][0]] for t in times_all]
|
||||||
|
from copy import deepcopy
|
||||||
|
valid_f_copy = deepcopy(valid_f)
|
||||||
|
import matplotlib as mpl
|
||||||
|
mpl.use('TkAgg')
|
||||||
|
import matplotlib.pyplot as plt
|
||||||
|
|
||||||
|
while True:
|
||||||
|
min_v, min_t = -1, 1e10
|
||||||
|
min_info, max_info = [], []
|
||||||
|
max_v, max_t = -1, -1
|
||||||
|
for nv in range(nViews):
|
||||||
|
if len(valid_f[nv]) == 1:
|
||||||
|
continue
|
||||||
|
# 存在多个的
|
||||||
|
min_info.append({
|
||||||
|
'v': nv,
|
||||||
|
't': times_all[nv][valid_f[nv][0]]
|
||||||
|
})
|
||||||
|
max_info.append({
|
||||||
|
'v': nv,
|
||||||
|
't': times_all[nv][valid_f[nv][-1]]
|
||||||
|
})
|
||||||
|
# 判断最小和最大的弹出谁
|
||||||
|
min_info.sort(key=lambda x:x['t'])
|
||||||
|
max_info.sort(key=lambda x:-x['t'])
|
||||||
|
if len(min_info) > 1 and len(max_info) > 1:
|
||||||
|
# delta_min = min_info[1]['t'] - min_info[0]['t']
|
||||||
|
# delta_max = max_info[0]['t'] - max_info[1]['t']
|
||||||
|
delta_max = max_info[0]['t'] - start_t
|
||||||
|
delta_min = start_t - min_info[0]['t']
|
||||||
|
if delta_max > delta_min:
|
||||||
|
valid_f[max_info[0]['v']].pop(-1)
|
||||||
|
else:
|
||||||
|
valid_f[min_info[0]['v']].pop(0)
|
||||||
|
else:
|
||||||
|
nv = min_info[0]['v']
|
||||||
|
t_min = times_all[nv][valid_f[0]]
|
||||||
|
t_max = times_all[nv][valid_f[1]]
|
||||||
|
delta_min = start_t - t_min
|
||||||
|
delta_max = t_max - start_t
|
||||||
|
if delta_max > delta_min:
|
||||||
|
valid_f[nv].pop(-1)
|
||||||
|
else:
|
||||||
|
valid_f[nv].pop(0)
|
||||||
|
break
|
||||||
|
plt.plot([0, nViews], [start_t, start_t])
|
||||||
|
for nv in range(len(valid_f)):
|
||||||
|
if len(valid_f[nv]) > 1:
|
||||||
|
start, end = valid_f[nv]
|
||||||
|
start, end = times_all[nv][start], times_all[nv][end]
|
||||||
|
plt.plot([nv, nv], [start, end])
|
||||||
|
else:
|
||||||
|
start, end = valid_f_copy[nv][0], valid_f_copy[nv][-1]
|
||||||
|
start, end = times_all[nv][start], times_all[nv][end]
|
||||||
|
plt.plot([nv, nv], [start, end])
|
||||||
|
plt.scatter(nv, times_all[nv][valid_f[nv]])
|
||||||
|
plt.show()
|
||||||
|
matched = np.arange(times_all[ref_view].shape[0]).reshape(1, -1).repeat(nViews, 0)
|
||||||
|
matched = np.arange(2).reshape(1, -1).repeat(nViews, 0)
|
||||||
|
start = np.array(valid_f).reshape(-1, 1)
|
||||||
|
matched += start
|
||||||
|
shape = np.array([t.shape[0] for t in times_all]).reshape(-1, 1) - 10
|
||||||
|
matched[matched<0] = -1
|
||||||
|
# matched[matched>shape] = -1
|
||||||
|
matched = matched[:, (matched!=-1).all(axis=0)]
|
||||||
|
matched_time = np.zeros_like(matched)
|
||||||
|
for nv in range(matched.shape[0]):
|
||||||
|
matched_time[nv] = times_all[nv][matched[nv]]
|
||||||
|
max_time = matched_time.max(axis=0)
|
||||||
|
min_time = matched_time.min(axis=0)
|
||||||
|
diff = max_time - min_time
|
||||||
|
step = matched_time[:, 1:] - matched_time[:, :-1]
|
||||||
|
headers = ['camera', 'start', 'end', 'delta_mean', 'delta_min', 'delta_max', 'diff_max', 'diff_min', 'diff_mean']
|
||||||
|
infos = []
|
||||||
|
dist_to_ref_all = 0
|
||||||
|
for nv, cam in enumerate(cams):
|
||||||
|
dist_to_ref = (matched_time[nv] - matched_time[ref_view]).tolist()
|
||||||
|
dist_to_ref_all += np.abs(dist_to_ref).mean()
|
||||||
|
dist_to_ref.sort(key=lambda x: abs(x))
|
||||||
|
infos.append([cam, matched_time[nv, 0], matched_time[nv, -1], step[nv].mean(), step[nv].min(), step[nv].max(), dist_to_ref[-1], dist_to_ref[0], np.abs(np.array(dist_to_ref)).mean()])
|
||||||
|
print(tabulate(infos, headers=headers))
|
||||||
|
# import matplotlib.pyplot as plt
|
||||||
|
# plt.plot(times_all[7][:100])
|
||||||
|
# plt.plot(times_all[ref_view][:100])
|
||||||
|
# plt.show()
|
||||||
|
# import ipdb;ipdb.set_trace()
|
||||||
|
print("Max sync difference = {}ms, Mean max sync difference = {:.1f}ms".format(diff.max(), diff.mean()))
|
||||||
|
print("Mean sync diff : {}".format(dist_to_ref_all/len(cams)))
|
||||||
|
if not args.nocheck: import ipdb;ipdb.set_trace()
|
||||||
|
return matched, matched_time
|
||||||
|
|
||||||
|
def copy_func(src, dst):
|
||||||
|
if args.keep2048:
|
||||||
|
shutil.copyfile(src, dst)
|
||||||
|
else:
|
||||||
|
img = cv2.imread(src)
|
||||||
|
img = cv2.resize(img, (1024, 1024))
|
||||||
|
if colors_params is not None:
|
||||||
|
sub = os.path.basename(os.path.dirname(dst))
|
||||||
|
M = colors_params[sub]
|
||||||
|
img = (np.clip((img.astype(np.float32)/255.) @ M, 0., 1.) * 255).astype(np.uint8)
|
||||||
|
cv2.imwrite(dst, img)
|
||||||
|
|
||||||
|
def copy_func_batch(src: list, dst: list):
|
||||||
|
assert(len(src) == len(dst))
|
||||||
|
for i in tqdm(range(len(src))):
|
||||||
|
copy_func(src[i], dst[i])
|
||||||
|
|
||||||
|
THREAD_CNT = 8
|
||||||
|
|
||||||
|
def copy_with_match(path, out, matched, imagelists, cams, multiple_thread = False):
|
||||||
|
print('---')
|
||||||
|
print('Copy {} to {}'.format(path, out))
|
||||||
|
print('---')
|
||||||
|
pad_2 = lambda x:'{:02d}'.format(int(x))
|
||||||
|
remove_cam = lambda x:x.replace('Camera_B', '').replace('Camera_', '').replace('Camera (', '').replace(')', '')
|
||||||
|
cvt_viewname = lambda x:pad_2(remove_cam(x))
|
||||||
|
|
||||||
|
reports = [[] for _ in range(matched.shape[1])]
|
||||||
|
for nv in tqdm(range(matched.shape[0])):
|
||||||
|
outdir = join(out, 'images', cvt_viewname(cams[nv]))
|
||||||
|
if os.path.exists(outdir):
|
||||||
|
if matched.shape[1] == len(os.listdir(outdir)):
|
||||||
|
print('exists enough images')
|
||||||
|
continue
|
||||||
|
else:
|
||||||
|
print('exists not enough images')
|
||||||
|
else:
|
||||||
|
os.makedirs(outdir, exist_ok=True)
|
||||||
|
imgname_old_s = [[] for _ in range(THREAD_CNT)]
|
||||||
|
imgname_new_s = [[] for _ in range(THREAD_CNT)]
|
||||||
|
for nfnew in range(matched.shape[1]):
|
||||||
|
nf = matched[nv, nfnew]
|
||||||
|
imgname_old = join(path, cams[nv], imagelists[cams[nv]][nf])
|
||||||
|
imgname_old_s[nfnew % THREAD_CNT].append(imgname_old)
|
||||||
|
imgname_new_s[nfnew % THREAD_CNT].append(join(outdir, '{:06d}.jpg'.format(nfnew)))
|
||||||
|
reports[nfnew].append(imgname_old)
|
||||||
|
if multiple_thread:
|
||||||
|
import threading
|
||||||
|
threads = []
|
||||||
|
for i in range(THREAD_CNT):
|
||||||
|
thread = threading.Thread(target=copy_func_batch, args=(imgname_old_s[i], imgname_new_s[i])) # 应该不存在任何数据竞争
|
||||||
|
thread.start()
|
||||||
|
threads.append(thread)
|
||||||
|
for thread in threads:
|
||||||
|
thread.join()
|
||||||
|
else:
|
||||||
|
for nfnew in tqdm(range(matched.shape[1]), desc='{}'.format(cams[nv])):
|
||||||
|
nf = matched[nv, nfnew]
|
||||||
|
imgname_old = join(path, cams[nv], imagelists[cams[nv]][nf])
|
||||||
|
imgname_new = join(outdir, '{:06d}.jpg'.format(nfnew))
|
||||||
|
copy_func(imgname_old, imgname_new)
|
||||||
|
save_json(join(out, 'match_name.json'), reports)
|
||||||
|
|
||||||
|
from tabulate import tabulate
|
||||||
|
def parse_time(imagelists, cams):
|
||||||
|
times_all = {}
|
||||||
|
headers = ['camera', 'frames', 'mean', 'min', 'max', 'number>mean', 'start', 'end']
|
||||||
|
MAX_STEP = 20
|
||||||
|
infos = []
|
||||||
|
start_time = -1
|
||||||
|
for cam in cams:
|
||||||
|
times = []
|
||||||
|
for imgname in imagelists[cam]:
|
||||||
|
time = parseImg(imgname)['time']
|
||||||
|
times.append(time)
|
||||||
|
times = np.array(times)
|
||||||
|
times_all[cam] = times
|
||||||
|
if start_time < 0:
|
||||||
|
start_time = times[0]
|
||||||
|
else:
|
||||||
|
start_time = min(start_time, times[0])
|
||||||
|
print('Start time: {}'.format(start_time))
|
||||||
|
for cam in cams:
|
||||||
|
times = times_all[cam]
|
||||||
|
times -= start_time
|
||||||
|
delta = times[1:] - times[:-1]
|
||||||
|
infos.append([cam, times.shape[0],
|
||||||
|
delta.mean(),
|
||||||
|
'{}/{}'.format(delta.min(), delta.argmin()),
|
||||||
|
'{}/{}'.format(delta.max(), delta.argmax()),
|
||||||
|
(delta>delta.mean()).sum(),
|
||||||
|
times[0]%60000,
|
||||||
|
times[-1]%60000])
|
||||||
|
print(tabulate(infos, headers=headers))
|
||||||
|
return times_all
|
||||||
|
|
||||||
|
def soft_sync(path, out, multiple_thread = False):
|
||||||
|
os.makedirs(out, exist_ok=True)
|
||||||
|
# 获取图像名称
|
||||||
|
cams, imagelists = getFileDict(path)
|
||||||
|
if args.static:
|
||||||
|
# 静止场景，直接保存第一帧图像
|
||||||
|
matched = np.zeros((len(cams), 1), dtype=np.int)
|
||||||
|
elif args.nosync:
|
||||||
|
assert len(cams) == 1
|
||||||
|
times_all = parse_time(imagelists, cams)
|
||||||
|
matched = np.arange(0, len(imagelists[cams[0]])).reshape(1, -1)
|
||||||
|
# matched = np.arange((1, len(imagelists[cams[0]])), dtype=np.int)
|
||||||
|
else:
|
||||||
|
# 获取图像时间
|
||||||
|
times_all = parse_time(imagelists, cams)
|
||||||
|
matched, matched_time = sync_by_name(imagelists, times_all, cams)
|
||||||
|
matched = matched[:, ::args.step]
|
||||||
|
times_all = {key:val.tolist() for key, val in times_all.items()}
|
||||||
|
save_json(join(out, 'timestamp.json'), times_all)
|
||||||
|
np.savetxt(join(out, 'sync_time.txt'), matched_time-matched_time.min(), fmt='%10d')
|
||||||
|
# 保存图像
|
||||||
|
copy_with_match(path, out, matched, imagelists, cams, multiple_thread)
|
||||||
|
|
||||||
|
def read_json(path):
|
||||||
|
with open(path) as f:
|
||||||
|
data = json.load(f)
|
||||||
|
return data
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
import argparse
|
||||||
|
parser = argparse.ArgumentParser(usage='''
|
||||||
|
origin=/path/to/CoreView_xxx
|
||||||
|
data=/path/to/output/xxx
|
||||||
|
- convert data: python3 scripts/dataset/pre_lightstage.py ${origin} ${data} --mp --ref_min
|
||||||
|
- keep origin resolution: --keep2048
|
||||||
|
- only copy one frame: --static
|
||||||
|
- set the color adjustment: --color /path/to/color
|
||||||
|
- skip the check: --nocheck
|
||||||
|
''')
|
||||||
|
parser.add_argument('path', type=str)
|
||||||
|
parser.add_argument('out', type=str)
|
||||||
|
parser.add_argument('--filter', type=str, nargs='+', default=[])
|
||||||
|
parser.add_argument('--num', type=int, default=1)
|
||||||
|
parser.add_argument('--ref', type=str, default=None)
|
||||||
|
parser.add_argument('--color', type=str, default=None)
|
||||||
|
parser.add_argument('--step', type=int, default=1)
|
||||||
|
parser.add_argument('--keep2048', action='store_true')
|
||||||
|
parser.add_argument('--static', action='store_true')
|
||||||
|
parser.add_argument('--ref_min', action='store_true')
|
||||||
|
parser.add_argument('--nosync', action='store_true')
|
||||||
|
parser.add_argument('--debug', action='store_true')
|
||||||
|
parser.add_argument("--mp", action='store_true')
|
||||||
|
parser.add_argument('--check', action='store_true')
|
||||||
|
parser.add_argument('--nocheck', action='store_true')
|
||||||
|
args = parser.parse_args()
|
||||||
|
|
||||||
|
# Reading color adjustment
|
||||||
|
if args.color is not None:
|
||||||
|
colors_params = {}
|
||||||
|
for sub in sorted(os.listdir(args.color)):
|
||||||
|
colors = read_json(join(args.color, sub, '000000.json'))
|
||||||
|
colors_params[sub] = np.array(colors['params'], dtype=np.float32)
|
||||||
|
print('Reading color adjustment from {}'.format(args.color))
|
||||||
|
else:
|
||||||
|
colors_params = None
|
||||||
|
cmd = 'python3 ' + ' '.join(sys.argv)
|
||||||
|
os.makedirs(args.out, exist_ok=True)
|
||||||
|
print(cmd, file=open(join(args.out, 'cmd.log'), 'w'))
|
||||||
|
filter_list = args.filter
|
||||||
|
|
||||||
|
if args.check:
|
||||||
|
timestamp = np.loadtxt(join(args.out, 'sync_time.txt'), dtype=np.int)
|
||||||
|
timestamp = timestamp[:, :10]
|
||||||
|
t = np.arange(timestamp.shape[1])
|
||||||
|
import matplotlib as mpl
|
||||||
|
mpl.use('TkAgg')
|
||||||
|
import matplotlib.pyplot as plt
|
||||||
|
for nv in range(timestamp.shape[0]):
|
||||||
|
plt.plot(t, timestamp[nv])
|
||||||
|
for nf in range(timestamp.shape[1]-1):
|
||||||
|
plt.plot([nf, nf+1], [timestamp[:, nf].mean(), timestamp[:, nf].mean()], c='k')
|
||||||
|
plt.plot([nf, nf+1], [timestamp[:, nf].min(), timestamp[:, nf].min()], c='r')
|
||||||
|
plt.plot([nf, nf+1], [timestamp[:, nf].max(), timestamp[:, nf].max()], c='g')
|
||||||
|
plt.show()
|
||||||
|
import ipdb; ipdb.set_trace()
|
||||||
|
else:
|
||||||
|
soft_sync(args.path, args.out, multiple_thread = args.mp)
|
||||||
Loading…
Reference in New Issue
Block a user