def dataset_iterator(self, video_dirs):
video_num = len(video_dirs)
iter_size = 150
iter_num = int(np.ceil(video_num / float(iter_size)))
for iter_ in range(iter_num):
iter_start = iter_ * iter_size
iter_videos = video_dirs[iter_start:iter_start + iter_size]
data_iter = DataIter()
num_videos = len(iter_videos)
instance_videos = []
for index in range(num_videos):
print('Processing {}/{}...'.format(iter_start + index,
video_num))
video_dir = iter_videos[index]
trackids = self._get_unique_trackids(video_dir)
for trackid in trackids:
instance_image_paths = glob.glob(video_dir + '/*' +
trackid + '.crop.x.jpg')
# sort image paths by frame number
instance_image_paths = sort_nicely(instance_image_paths)
# get image absolute path
instance_image_paths = [
os.path.abspath(p) for p in instance_image_paths
]
instance_videos.append(instance_image_paths)
data_iter.num_videos = len(instance_videos)
data_iter.instance_videos = instance_videos
yield data_iter
def dataset_iterator(self, video_dirs):
video_num = len(video_dirs)
iter_size = 150
iter_num = int(np.ceil(video_num / float(iter_size)))
for iter_ in range(iter_num):
iter_start = iter_ * iter_size
iter_videos = video_dirs[iter_start: iter_start + iter_size]
data_iter = DataIter()
num_videos = len(iter_videos)
instance_videos = []
for index in range(num_videos):
print('Processing {}/{}...'.format(iter_start + index, video_num))
video_dir = iter_videos[index]
trackids = self._get_unique_trackids(video_dir)
for trackid in trackids:
instance_image_paths = glob.glob(video_dir + '/*' + trackid + '.crop.x.jpg')
# sort image paths by frame number
instance_image_paths = sort_nicely(instance_image_paths)
# get image absolute path
instance_image_paths = [os.path.abspath(p) for p in instance_image_paths]
instance_videos.append(instance_image_paths)
data_iter.num_videos = len(instance_videos)
data_iter.instance_videos = instance_videos
yield data_iter
def main(checkpoint, input_files):
os.environ['CUDA_VISIBLE_DEVICES'] = auto_select_gpu()
model_config, _, track_config = load_cfgs(checkpoint)
track_config['log_level'] = 1
track_config["is_video"] = False
g = tf.Graph()
with g.as_default():
model = inference_wrapper.InferenceWrapper()
restore_fn = model.build_graph_from_config(model_config, track_config,
checkpoint)
g.finalize()
if not osp.isdir(track_config['log_dir']):
logging.info('Creating inference directory: %s',
track_config['log_dir'])
mkdir_p(track_config['log_dir'])
video_dirs = []
for file_pattern in input_files.split(","):
video_dirs.extend(glob(file_pattern))
logging.info("Running tracking on %d videos matching %s", len(video_dirs),
input_files)
gpu_options = tf.GPUOptions(allow_growth=True)
sess_config = tf.ConfigProto(gpu_options=gpu_options)
with tf.Session(graph=g, config=sess_config) as sess:
restore_fn(sess)
tracker = Tracker(model,
model_config=model_config,
track_config=track_config)
for video_dir in video_dirs:
if not osp.isdir(video_dir):
logging.warning(
'{} is not a directory, skipping...'.format(video_dir))
continue
video_name = osp.basename(video_dir)
video_log_dir = osp.join(track_config['log_dir'], video_name)
mkdir_p(video_log_dir)
filenames = sort_nicely(glob(video_dir + '/img/*.jpg'))
first_line = open(video_dir + '/groundtruth_rect.txt').readline()
bb = [int(v) for v in first_line.strip().split(',')]
# Rectangle: [x,y,width,height]
init_bb = Rectangle(bb[0] - 1, bb[1] - 1, bb[2],
bb[3]) # 0-index in python
trajectory = tracker.track(sess, init_bb, filenames, video_log_dir)
with open(osp.join(video_log_dir, 'track_rect.txt'), 'w') as f:
for region in trajectory:
rect_str = '{},{},{},{}\n'.format(region.x + 1,
region.y + 1,
region.width,
region.height)
f.write(rect_str)
def main(checkpoint, input_files):
os.environ['CUDA_VISIBLE_DEVICES'] = auto_select_gpu()
model_config, _, track_config = load_cfgs(checkpoint)
track_config['log_level'] = 1
g = tf.Graph()
with g.as_default():
model = inference_wrapper.InferenceWrapper()
restore_fn = model.build_graph_from_config(model_config, track_config, checkpoint)
g.finalize()
if not osp.isdir(track_config['log_dir']):
logging.info('Creating inference directory: %s', track_config['log_dir'])
mkdir_p(track_config['log_dir'])
video_dirs = []
for file_pattern in input_files.split(","):
video_dirs.extend(glob(file_pattern))
logging.info("Running tracking on %d videos matching %s", len(video_dirs), input_files)
gpu_options = tf.GPUOptions(allow_growth=True)
sess_config = tf.ConfigProto(gpu_options=gpu_options)
with tf.Session(graph=g, config=sess_config) as sess:
restore_fn(sess)
tracker = Tracker(model, model_config=model_config, track_config=track_config)
for video_dir in video_dirs:
if not osp.isdir(video_dir):
logging.warning('{} is not a directory, skipping...'.format(video_dir))
continue
video_name = osp.basename(video_dir)
video_log_dir = osp.join(track_config['log_dir'], video_name)
mkdir_p(video_log_dir)
filenames = sort_nicely(glob(video_dir + '/img/*.jpg'))
first_line = open(video_dir + '/groundtruth_rect.txt').readline()
bb = [int(v) for v in first_line.strip().split(',')]
init_bb = Rectangle(bb[0] - 1, bb[1] - 1, bb[2], bb[3]) # 0-index in python
trajectory = tracker.track(sess, init_bb, filenames, video_log_dir)
with open(osp.join(video_log_dir, 'track_rect.txt'), 'w') as f:
for region in trajectory:
rect_str = '{},{},{},{}\n'.format(region.x + 1, region.y + 1,
region.width, region.height)
f.write(rect_str)
def dataset_iterator(self, video_dirs):
anno_dir = 'data/GOT-10k'
video_num = len(video_dirs)
iter_size = 150
iter_num = int(np.ceil(video_num / float(iter_size)))
for iter_ in range(iter_num):
iter_start = iter_ * iter_size
iter_videos = video_dirs[iter_start:iter_start + iter_size]
data_iter = DataIter()
num_videos = len(iter_videos)
instance_videos = []
instance_ann = []
for index in range(num_videos):
print('Processing {}/{}...'.format(iter_start + index,
video_num))
video_dir = iter_videos[index]
subdirs = video_dir.split('/')
ann_vid_dir = osp.join(anno_dir, subdirs[-2], subdirs[-1])
with open(osp.join(ann_vid_dir, 'groundtruth.txt')) as f:
ann_content = f.readlines()
dest = osp.join('../SiamFC-TensorFlow/data/got10k-Curation',
subdirs[-2], subdirs[-1])
copyfile(osp.join(ann_vid_dir, ''))
instance_image_paths = glob.glob(video_dir + '/*.crop.x.jpg')
# sort image paths by frame number
instance_image_paths = sort_nicely(instance_image_paths)
assert len(instance_image_paths) == len(ann_content)
try:
# get annotations
bboxs = []
for ann in ann_content:
ann = ann.strip()
bbox = ann.split(',')
bbox = [float(bb) for bb in bbox] # [xmin, ymin, w, h]
w = bbox[2]
h = bbox[3]
context_amount = 0.5
size_z = 127
size_x = 255
wc_z = w + context_amount * (w + h)
hc_z = h + context_amount * (w + h)
s_z = np.sqrt(wc_z * hc_z)
scale_z = size_z / s_z
d_search = (size_x - size_z) / 2
pad = d_search / scale_z
s_x = s_z + 2 * pad
wn = w / s_x * size_x * 2
hn = h / s_x * size_x * 2
if wn < 1 or hn < 1:
ratio = wn / hn
if ratio > 1.:
bboxs.append([128., 128., 85., 85. / ratio])
else:
bboxs.append([128., 128., 85. * ratio, 85.])
else:
bboxs.append([128, 128, wn, hn])
# get image absolute path
#instance_image_paths = [os.path.abspath(p) for p in instance_image_paths]
instance_videos.append(instance_image_paths)
instance_ann.append(bboxs)
except:
print('Skipped: ' + video_dir)
data_iter.num_videos = len(instance_videos)
data_iter.instance_videos = instance_videos
data_iter.instance_ann = instance_ann
yield data_iter
action="store_true")
args, _ = parser.parse_known_args()
first_line = open(args.image_filepath + '/groundtruth_rect.txt').readline()
bbox = [int(v) for v in first_line.strip().split(',')]
init_bbox = Rectangle(bbox[0], bbox[1], bbox[2],
bbox[3]) # 0-index in python
tracker = SiameseTracking(args.config_filepath, args.separate_mode,
osp.join(args.models_dir, args.whole_model),
osp.join(args.models_dir, args.template_model),
osp.join(args.models_dir, args.search_model),
osp.join(args.models_dir, args.cross_model))
filenames = sort_nicely(glob(args.image_filepath + '/img/*.jpg'))
first_image = cv2.imread(filenames[0])
template_image = tracker.update_template_image(first_image, init_bbox)
if not args.headless:
cv2.imshow('template_image', template_image.astype(np.uint8))
for i, filename in enumerate(filenames):
if i > 0:
input_image = cv2.imread(filenames[i])
dt1 = datetime.datetime.now()
outputs = tracker.inference(template_image, input_image)
dt2 = datetime.datetime.now()
print("tracking du: {}".format(dt2.timestamp() - dt1.timestamp()))
#print(sess.run(tf.report_uninitialized_variables()))
av1 = tf.all_variables()
tracker = Tracker(model, model_config=model_config, track_config=track_config)
for video_dir in video_dirs:
if not osp.isdir(video_dir):
logging.warning('{} is not a directory, skipping...'.format(video_dir))
continue
video_name = osp.basename(video_dir)
video_log_dir = "tmp"
mkdir_p(video_log_dir)
filenames = sort_nicely(glob(video_dir + '/img/*.jpg'))
first_line = open(video_dir + '/groundtruth_rect.txt').readline()
bb = [int(v) for v in first_line.strip().replace(' ', ',').replace('\t', ',').split(',')]
init_bb = Rectangle(bb[0] - 1, bb[1] - 1, bb[2], bb[3]) # 0-index in python
print("######{0},{1}".format(video_dir, len(filenames)))
# =============================================================================
# for i in range(10):
# print ("fixed classid: {}".format(i))
# trajectory = tracker.track(sess, init_bb, filenames, video_log_dir, str(i))
# with open(osp.join(video_log_dir, 'track_rect.txt'), 'w') as f:
# for region in trajectory:
# rect_str = '{},{},{},{}\n'.format(region.x + 1, region.y + 1,
# region.width, region.height)
# f.write(rect_str)
#
def main(checkpoint, input_files):
os.environ['CUDA_VISIBLE_DEVICES'] = auto_select_gpu()
model_config, _, track_config = load_cfgs(checkpoint)
track_config['log_level'] = 1
g = tf.Graph()
with g.as_default():
model = inference_wrapper.InferenceWrapper()
restore_fn = model.build_graph_from_config(model_config, track_config,
checkpoint)
g.finalize()
if not osp.isdir(track_config['log_dir']):
logging.info('Creating inference directory: %s',
track_config['log_dir'])
mkdir_p(track_config['log_dir'])
video_dirs = []
for file_pattern in input_files.split(","):
video_dirs.extend(glob(file_pattern))
logging.info("Running tracking on %d videos matching %s", len(video_dirs),
input_files)
gpu_options = tf.GPUOptions(allow_growth=True)
sess_config = tf.ConfigProto(gpu_options=gpu_options)
with tf.Session(graph=g, config=sess_config) as sess:
restore_fn(sess)
tracker = Tracker(model,
model_config=model_config,
track_config=track_config)
for video_dir in video_dirs:
if not osp.isdir(video_dir):
logging.warning(
'{} is not a directory, skipping...'.format(video_dir))
continue
video_name = osp.basename(video_dir)
video_log_dir = osp.join(track_config['log_dir'], video_name)
mkdir_p(video_log_dir)
filenames = sort_nicely(
glob(video_dir + '/img/*.jpg') +
glob(video_dir + '/img/*.png'))
first_line = open(video_dir + '/groundtruth_rect.txt').readline()
bb = [int(v) for v in first_line.strip().split(',')]
init_bb = Rectangle(bb[0] - 1, bb[1] - 1, bb[2],
bb[3]) # 0-index in python
trajectory = tracker.track(sess, init_bb, filenames, video_log_dir)
with open(osp.join(video_log_dir, 'track_rect.txt'), 'w') as f:
for region in trajectory:
rect_str = '{},{},{},{}\n'.format(region.x + 1,
region.y + 1,
region.width,
region.height)
f.write(rect_str)
with open(osp.join(video_log_dir, 'bboxes.json'), 'r') as f:
data = json.load(f)
final_output = {}
for i, fname in enumerate(data.keys()):
img = np.array(Image.open(fname).convert('RGB'))
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
#print(img,img.shape)
bboxes = data[fname]
bboxes = list(
map(
lambda x: list(
map(lambda y: float(y),
x.strip().split(','))), bboxes))
arr = []
for x, y, w, h in bboxes:
ymin, xmin, ymax, xmax = int(y), int(x), int(y +
h), int(x + w)
img = cv2.rectangle(img, (xmin, ymin), (xmax, ymax),
(0, 255, 0, 255), 2)
arr.append([ymin, xmin, ymax, xmax])
final_output[fname] = arr
name = osp.basename(fname)
name = osp.splitext(name)[0]
W, H, _ = img.shape
cv2.imshow("Pic", cv2.resize(img, (W // 2, H // 2)))
cv2.waitKey(0)
out_folder = osp.join(video_log_dir, "Outputs")
mkdir_p(out_folder)
cv2.imwrite(osp.join(out_folder, f"{name}_bbox.png"), img)
with open(osp.join(out_folder, "output.json"), "w") as f:
json.dump(final_output, f, indent=4)
cv2.destroyAllWindows()
