def nondist_validation(self, dataloader, current_iter, tb_logger,
save_img):
assert dataloader is None, 'Validation dataloader should be None.'
self.test()
result = tensor2img(self.output, min_max=(-1, 1))
if self.opt['is_train']:
save_img_path = osp.join(self.opt['path']['visualization'],
'train', f'train_{current_iter}.png')
else:
save_img_path = osp.join(self.opt['path']['visualization'], 'test',
f'test_{self.opt["name"]}.png')
mmcv.imwrite(result, save_img_path)
# add sample images to tb_logger
result = (result / 255.).astype(np.float32)
result = mmcv.bgr2rgb(result)
if tb_logger is not None:
tb_logger.add_image(
'samples', result, global_step=current_iter, dataformats='HWC')
def predict(self, img, threshold):
result = inference_detector(self.model, img)
res_img = self.model.show_result(img, result, score_thr=threshold, show=False)
_image_name = img.split('\\')[-1].split('.')[0]
# maybe only happen for the first time initialization
if not _image_name:
return
_image_name = _image_name + '.png'
out = os.path.join('results/', _image_name)
mmcv.imwrite(res_img, out)
return _image_name
def forward_test(self,
lq,
gt=None,
meta=None,
save_image=False,
save_path=None,
iteration=None):
"""Testing forward function.
Args:
lq (Tensor): LQ Tensor with shape (n, c, h, w).
gt (Tensor): GT Tensor with shape (n, c, h, w). Default: None.
save_image (bool): Whether to save image. Default: False.
save_path (str): Path to save image. Default: None.
iteration (int): Iteration for the saving image name.
Default: None.
Returns:
dict: Output results.
"""
_model = self.generator_ema if self.is_use_ema else self.generator
output = _model(lq)
if self.test_cfg is not None and self.test_cfg.get(
'metrics', None) and gt is not None:
results = dict(eval_result=self.evaluate(output, gt))
else:
results = dict(lq=lq.cpu(), output=output.cpu())
# save image
if save_image:
lq_path = meta[0]['lq_path']
folder_name = osp.splitext(osp.basename(lq_path))[0]
if isinstance(iteration, numbers.Number):
save_path = osp.join(save_path, folder_name,
f'{folder_name}-{iteration + 1:06d}.png')
elif iteration is None:
save_path = osp.join(save_path, f'{folder_name}.png')
else:
raise ValueError('iteration should be number or None, '
f'but got {type(iteration)}')
mmcv.imwrite(tensor2img(output), save_path)
return results
def main():
args = parse_args()
if not os.path.isfile(args.img_path):
raise ValueError('It seems that you did not input a valid '
'"image_path". Please double check your input, or '
'you may want to use "restoration_video_demo.py" '
'for video restoration.')
model = init_model(args.config,
args.checkpoint,
device=torch.device('cuda', args.device))
output = restoration_inference(model, args.img_path)
output = tensor2img(output)
mmcv.imwrite(output, args.save_path)
if args.imshow:
mmcv.imshow(output, 'predicted restoration result')
def process(data, img_path_prefix, out_dir):
if data is None:
return
# Dirty hack for multi-processing
img_path, words, word_bboxes, char_bbox_grps = data
img_dir, img_name = os.path.split(img_path)
img_name = os.path.splitext(img_name)[0]
input_img = mmcv.imread(os.path.join(img_path_prefix, img_path))
output_sub_dir = os.path.join(out_dir, img_dir)
if not os.path.exists(output_sub_dir):
try:
os.makedirs(output_sub_dir)
except FileExistsError:
pass # occurs when multi-proessing
for i, word in enumerate(words):
output_image_patch_name = f'{img_name}_{i}.png'
output_label_name = f'{img_name}_{i}.txt'
output_image_patch_path = os.path.join(output_sub_dir,
output_image_patch_name)
output_label_path = os.path.join(output_sub_dir, output_label_name)
if os.path.exists(output_image_patch_path) and os.path.exists(
output_label_path):
continue
word_bbox = word_bboxes[i]
min_x, max_x = int(min(word_bbox[::2])), int(max(word_bbox[::2]))
min_y, max_y = int(min(word_bbox[1::2])), int(max(word_bbox[1::2]))
cropped_img = input_img[min_y:max_y, min_x:max_x]
if cropped_img.shape[0] <= 0 or cropped_img.shape[1] <= 0:
continue
char_bbox_grp = np.array(char_bbox_grps[i])
char_bbox_grp[:, ::2] -= min_x
char_bbox_grp[:, 1::2] -= min_y
mmcv.imwrite(cropped_img, output_image_patch_path)
with open(output_label_path, 'w') as output_label_file:
output_label_file.write(word + '\n')
for cbox in char_bbox_grp:
output_label_file.write('%d %d %d %d %d %d %d %d\n' %
tuple(cbox.tolist()))
def main():
args = parse_args()
os.makedirs(args.output_root, exist_ok=True)
dataset = COCO(args.annotation_path)
for img_id, img_info in tqdm(dataset.imgs.items()):
filename = img_info["file_name"]
img = mmcv.imread(osp.join(args.img_root, filename))
ann_ids = dataset.getAnnIds(imgIds=[img_id])
ann_info = dataset.loadAnns(ann_ids)
for i, ann in enumerate(ann_info):
x1, y1, w, h = map(int, ann["bbox"])
category_id = ann["category_id"]
crop = img[y1 : y1 + h, x1 : x1 + w]
output_path = osp.join(args.output_root, f"{x1}_{y1}_{w}_{h}_{filename}")
if w > 6 and h > 6:
if args.from_predict:
if category_id == 2 and ann["score"] > SCORE_THRESHOLD: # prediction
mmcv.imwrite(crop, output_path)
elif category_id == 1 and img_info["source"] in ["arvalis_1", "arvalis_3", "rres_1", "inrae_1"]:
mmcv.imwrite(crop, output_path)
def dump_frames(vid_item):
full_path, vid_path, vid_id = vid_item
vid_name = vid_path.split('.')[0]
out_full_path = osp.join(args.out_dir, vid_name)
try:
os.mkdir(out_full_path)
except OSError:
pass
vr = mmcv.VideoReader(full_path)
for i in range(len(vr)):
if vr[i] is not None:
mmcv.imwrite(vr[i],
'{}/img_{:05d}.jpg'.format(out_full_path, i + 1))
else:
print('[Warning] length inconsistent!'
'Early stop with {} out of {} frames'.format(i + 1, len(vr)))
break
print('{} done with {} frames'.format(vid_name, len(vr)))
sys.stdout.flush()
return True
def main():
args = parse_args()
# rename_pth(args.checkpoint)
# print('rename success')
model = init_model(args.config,
args.checkpoint,
device=torch.device('cuda', args.device))
for i in model.state_dict():
print(i)
pred_alpha = matting_inference(model, args.img_path,
args.trimap_path) * 255
# print(pred_alpha)
mmcv.imwrite(pred_alpha, args.save_path)
if args.imshow:
mmcv.imshow(pred_alpha, 'predicted alpha matte')
def _pan2json(self, results, outfile_prefix):
"""Convert panoptic results to COCO panoptic json style."""
label2cat = dict((v, k) for (k, v) in self.cat2label.items())
pred_annotations = []
outdir = os.path.join(os.path.dirname(outfile_prefix), 'panoptic')
for idx in range(len(self)):
img_id = self.img_ids[idx]
segm_file = self.data_infos[idx]['segm_file']
pan = results[idx]
pan_labels = np.unique(pan)
segm_info = []
for pan_label in pan_labels:
sem_label = pan_label % INSTANCE_OFFSET
# We reserve the length of self.CLASSES for VOID label
if sem_label == len(self.CLASSES):
continue
# convert sem_label to json label
cat_id = label2cat[sem_label]
is_thing = self.categories[cat_id]['isthing']
mask = pan == pan_label
area = mask.sum()
segm_info.append({
'id': int(pan_label),
'category_id': cat_id,
'isthing': is_thing,
'area': int(area)
})
# evaluation script uses 0 for VOID label.
pan[pan % INSTANCE_OFFSET == len(self.CLASSES)] = VOID
pan = id2rgb(pan).astype(np.uint8)
mmcv.imwrite(pan[:, :, ::-1], os.path.join(outdir, segm_file))
record = {
'image_id': img_id,
'segments_info': segm_info,
'file_name': segm_file
}
pred_annotations.append(record)
pan_json_results = dict(annotations=pred_annotations)
return pan_json_results
def process_level(
src_img,
annotation,
dst_image_root,
ignore_image_root,
preserve_vertical,
split,
format,
para_idx,
img_idx,
line_idx,
word_idx=None,
):
vertices = annotation['vertices']
text_label = annotation['text']
segmentation = [i for j in vertices for i in j]
x, y, w, h = seg2bbox(segmentation)
x, y = max(0, math.floor(x)), max(0, math.floor(y))
w, h = math.ceil(w), math.ceil(h)
dst_img = src_img[y:y + h, x:x + w]
if word_idx:
dst_img_name = f'img_{img_idx}_{para_idx}_{line_idx}_{word_idx}.jpg'
else:
dst_img_name = f'img_{img_idx}_{para_idx}_{line_idx}.jpg'
if not preserve_vertical and h / w > 2 and split == 'train':
dst_img_path = osp.join(ignore_image_root, dst_img_name)
else:
dst_img_path = osp.join(dst_image_root, dst_img_name)
mmcv.imwrite(dst_img, dst_img_path)
if format == 'txt':
label = (f'{osp.basename(dst_image_root)}/{dst_img_name}'
f' {text_label}')
elif format == 'jsonl':
label = json.dumps({
'filename': f'{osp.basename(dst_image_root)}/{dst_img_name}',
'text': text_label
})
else:
raise NotImplementedError
return label
def process_img(args, src_image_root, dst_image_root, ignore_image_root,
preserve_vertical, split, format):
# Dirty hack for multi-processing
img_idx, img_info, anns = args
src_img = mmcv.imread(osp.join(src_image_root, img_info['file_name']))
labels = []
for ann_idx, ann in enumerate(anns):
text_label = ann['utf8_string']
# Ignore illegible or non-English words
if ann['language'] == 'not english':
continue
if ann['legibility'] == 'illegible':
continue
x, y, w, h = ann['bbox']
x, y = max(0, math.floor(x)), max(0, math.floor(y))
w, h = math.ceil(w), math.ceil(h)
dst_img = src_img[y:y + h, x:x + w]
dst_img_name = f'img_{img_idx}_{ann_idx}.jpg'
if not preserve_vertical and h / w > 2 and split == 'train':
dst_img_path = osp.join(ignore_image_root, dst_img_name)
else:
dst_img_path = osp.join(dst_image_root, dst_img_name)
mmcv.imwrite(dst_img, dst_img_path)
if format == 'txt':
labels.append(f'{osp.basename(dst_image_root)}/{dst_img_name}'
f' {text_label}')
elif format == 'jsonl':
labels.append(
json.dumps({
'filename':
f'{osp.basename(dst_image_root)}/{dst_img_name}',
'text': text_label
}))
else:
raise NotImplementedError
return labels
def vis_seg_ood(data, result, img_norm_cfg, save_dir, score_thr):
img_tensor = data['img'][0]
if len(img_tensor.shape) < 4:
img_tensor = img_tensor.unsqueeze(0)
try:
img_metas = data['img_meta'][0].data[0]
except:
img_metas = data['img_meta'][0]
imgs = tensor2imgs(img_tensor, **img_norm_cfg)
assert len(imgs) == len(img_metas)
for img, img_meta, cur_result in zip(imgs, img_metas, result):
h, w, _ = img_meta['img_shape']
img_show = img[:h, :w, :]
ood_seg = F.interpolate(cur_result['ca_ood_seg'].unsqueeze(0).unsqueeze(0), img_show.shape[:2])[0,0]
img_show[ood_seg>score_thr] = 0.7 * img_show[ood_seg>score_thr] + 0.3 * np.array((0, 0, 255))
mmcv.imwrite(img_show, '{}'.format(save_dir))
def save_image(self, pred_alpha, meta, save_path, iteration):
"""Save predicted alpha to file.
Args:
pred_alpha (np.ndarray): The predicted alpha matte of shape (H, W).
meta (list[dict]): Meta data about the current data batch.
Currently only batch_size 1 is supported. Required keys in the
meta dict are ``merged_path``.
save_path (str): The directory to save predicted alpha matte.
iteration (int | None): If given as None, the saved alpha matte
will have the same file name with ``merged_path`` in meta dict.
If given as an int, the saved alpha matte would named with
postfix ``_{iteration}.png``.
"""
image_stem = Path(meta[0]['merged_path']).stem
if iteration is None:
save_path = osp.join(save_path, f'{image_stem}.png')
else:
save_path = osp.join(save_path,
f'{image_stem}_{iteration + 1:06d}.png')
mmcv.imwrite(pred_alpha * 255, save_path)
def main():
flag_train = False
if flag_train:
for j in range(1,6):
data_path = osp.join(data_dir, 'data_batch_' + str(j)) # data_batch_1, data_batch_2, data_batch_3, data_batch_4, data_batch_5
train_data = unpickle(data_path)
print(data_path + ' is processing ... ')
for i in range(10000):
img = np.reshape(train_data[b'data'][i], (3, 32, 32)).transpose(0, 1, 2)
label_num = str(train_data[b'labels'][i])
output_dir = osp.join(train_output, label_num)
if not osp.isdir(output_dir):
os.makedirs(output_dir)
img_name = label_num + '_' + str(i + (j - 1) * 10000) + '.png'
img_path = osp.join(output_dir, img_name)
mmcv.imwrite(img, img_path)
print (data_path + 'loaded.')
else:
print ('test_batch is processing ...')
test_data_path = osp.join(data_dir, 'test_batch')
test_data = unpickle(test_data_path)
for i in range(10000):
img = np.reshape(test_data[b'data'][i], (3, 32, 32))
img = img.transpose(1, 2, 0)
label_num = str(test_data[b'labels'][i])
output_dir = osp.join(test_output, label_num)
if not osp.exists(output_dir):
os.makedirs(output_dir)
img_name = label_num + '_' + str(i) + '.png'
img_path = osp.join(output_dir, img_name)
mmcv.imwrite(img, img_path)
print ('test_batch' + 'loaded.')
def main():
parser = ArgumentParser()
parser.add_argument('img', help='Image file.')
parser.add_argument('config', help='Config file.')
parser.add_argument('checkpoint', help='Checkpoint file.')
parser.add_argument('save_path', help='Path to save visualized image.')
parser.add_argument('--device',
default='cuda:0',
help='Device used for inference.')
parser.add_argument('--imshow',
action='store_true',
help='Whether show image with OpenCV.')
args = parser.parse_args()
# build the model from a config file and a checkpoint file
model = init_detector(args.config, args.checkpoint, device=args.device)
if model.cfg.data.test['type'] == 'ConcatDataset':
model.cfg.data.test.pipeline = model.cfg.data.test['datasets'][
0].pipeline
# test a single image
print(args.img)
s = time.time()
with open(args.img, 'r') as ff:
lines = ff.readlines()
for i, line in enumerate(lines):
imgPath = line.strip()
imgPath = f"qtests/{imgPath}"
imgName = imgPath.split('/')[-1]
print(imgPath)
result = model_inference(model, imgPath)
print(result)
#show the results
img = model.show_result(imgPath, result, out_file=None, show=False)
print("time", time.time() - s)
mmcv.imwrite(img, f"{args.save_path}/{imgName}.jpg")
if args.imshow:
mmcv.imshow(img, 'predicted results')
def generate_ann(root_path, split, image_infos, format):
dst_image_root = osp.join(root_path, 'crops', split)
dst_label_file = osp.join(root_path, f'{split}_label.{format}')
os.makedirs(dst_image_root, exist_ok=True)
lines = []
for image_info in image_infos:
index = 1
src_img_path = osp.join(root_path, 'imgs', image_info['file_name'])
image = mmcv.imread(src_img_path)
src_img_root = image_info['file_name'].split('.')[0]
for anno in image_info['anno_info']:
word = anno['word']
dst_img = crop_img(image, anno['bbox'], 0, 0)
# Skip invalid annotations
if min(dst_img.shape) == 0:
continue
dst_img_name = f'{src_img_root}_{index}.png'
index += 1
dst_img_path = osp.join(dst_image_root, dst_img_name)
mmcv.imwrite(dst_img, dst_img_path)
if format == 'txt':
lines.append(f'{osp.basename(dst_image_root)}/{dst_img_name} '
f'{word}')
elif format == 'jsonl':
lines.append(
json.dumps({
'filename':
f'{osp.basename(dst_image_root)}/{dst_img_name}',
'text': word
}))
else:
raise NotImplementedError
list_to_file(dst_label_file, lines)
def _draw_lines_ls_points_ls(img,
lines_ls,
points_ls=None,
line_colors='green',
point_colors='red',
out_file=None,
line_thickness=1,
point_thickness=1,
box=False):
if lines_ls is not None:
assert isinstance(lines_ls, list)
if lines_ls is not None and isinstance(line_colors, str):
line_colors = [line_colors] * len(lines_ls)
if not isinstance(line_thickness, list):
line_thickness = [line_thickness] * len(lines_ls)
if points_ls is not None:
assert isinstance(points_ls, list)
if points_ls is not None and isinstance(point_colors, str):
point_colors = [point_colors] * len(points_ls)
if not isinstance(point_thickness, list):
point_thickness = [point_thickness] * len(points_ls)
img = _read_img(img)
if lines_ls is not None:
for i, lines in enumerate(lines_ls):
img = _draw_lines(img,
lines,
line_colors[i],
line_thickness[i],
box=box)
if points_ls is not None:
for i, points in enumerate(points_ls):
img = _draw_points(img, points, point_colors[i],
point_thickness[i])
if out_file is not None:
mmcv.imwrite(img, out_file)
print('\n', out_file)
return img
def gen_pack_zbuf_render(self):
for line in tqdm.tqdm(self.lines):
pattern, num_str = line
base = osp.join(self.data_root, pattern)
num = int(num_str)
scene = Scene(base, num)
left = scene.left
right = scene.right
bgr = self._gen_pack_zbuf_render_side(left)
fname = osp.join(self.save_dir, f"{pattern}/{num_str}.left.png")
if bgr is not None:
mmcv.imwrite(bgr, fname)
else:
print(f"{fname} is None.")
bgr = self._gen_pack_zbuf_render_side(right)
fname = osp.join(self.save_dir, f"{pattern}/{num_str}.right.png")
if bgr is not None:
mmcv.imwrite(bgr, fname)
else:
print(f"{fname} is None.")
def vis_gt_known_ood(data, gt, img_norm_cfg, save_dir, palette='cityscapes', last_cls=19):
img_tensor = data['img'][0]
seg_color_map = get_color_map(palette)
if len(img_tensor.shape) < 4:
img_tensor = img_tensor.unsqueeze(0)
try:
img_metas = data['img_meta'][0].data[0]
except:
img_metas = data['img_meta'][0]
imgs = tensor2imgs(img_tensor, **img_norm_cfg)
assert len(imgs) == len(img_metas)
for img, img_meta, img_gt in zip(imgs, img_metas, gt):
h, w, _ = img_meta['img_shape']
img_show = img[:h, :w, :]
img_gt = torch.tensor(img_gt).unsqueeze(0).unsqueeze(0)
full_seg = F.interpolate(img_gt.float(),
img.shape[:2], mode='nearest')[0,0]
full_seg = full_seg.cpu().numpy().astype(np.uint8)
full_seg = full_seg[:h, :w]
known_seg = full_seg.copy()
ood_seg = np.zeros_like(full_seg)
known_seg[full_seg > last_cls-1] = 255
ood_seg[full_seg == last_cls] = 1
seg_show = img_show.copy()
for k, v in seg_color_map.items():
cur_mask = (known_seg==k)
seg_show[cur_mask] = seg_show[cur_mask] * 0.5 + np.asarray(v[::-1], np.uint8) * 0.5
img_show[ood_seg==1] = 0.5 * img_show[ood_seg==1] + 0.5 * np.array((255, 0, 0)[::-1])
mmcv.imwrite(img_show, '{}'.format(save_dir))
mmcv.imwrite(seg_show, '{}'.format(save_dir.replace('ood', 'seg')))
def process_img(args, src_image_root, dst_image_root):
# Dirty hack for multi-processing
img_idx, img_info, anns = args
src_img = mmcv.imread(osp.join(src_image_root, img_info['file_name']))
labels = []
for ann_idx, ann in enumerate(anns):
text_label = ann['utf8_string']
# Ignore illegible or non-English words
if text_label == '.':
continue
x, y, w, h = ann['bbox']
x, y = max(0, math.floor(x)), max(0, math.floor(y))
w, h = math.ceil(w), math.ceil(h)
dst_img = src_img[y:y + h, x:x + w]
dst_img_name = f'img_{img_idx}_{ann_idx}.jpg'
dst_img_path = osp.join(dst_image_root, dst_img_name)
mmcv.imwrite(dst_img, dst_img_path)
labels.append(f'{osp.basename(dst_image_root)}/{dst_img_name}'
f' {text_label}')
return labels
def show_result(img, result, dataset='coco', score_thr=0.3, out_file=None):
img = mmcv.imread(img)
class_names = get_classes(dataset)
if isinstance(result, tuple):
bbox_result, segm_result = result
else:
bbox_result, segm_result = result, None
bboxes = np.vstack(bbox_result)
f = open('tmp.txt', 'w')
for i in range(bboxes.shape[0]):
write_str = "{:.2f},{:.2f},{:.2f},{:.2f},{:.2f}\n".format(
bboxes[i][0], bboxes[i][1], bboxes[i][2], bboxes[i][3],
bboxes[i][4])
f.write(write_str)
f.close()
# draw segmentation masks
if segm_result is not None:
segms = mmcv.concat_list(segm_result)
inds = np.where(bboxes[:, -1] > score_thr)[0]
for i in inds:
color_mask = np.random.randint(0, 256, (1, 3), dtype=np.uint8)
mask = maskUtils.decode(segms[i]).astype(np.bool)
img[mask] = img[mask] * 0.5 + color_mask * 0.5
# draw bounding boxes
labels = [
np.full(bbox.shape[0], i, dtype=np.int32)
for i, bbox in enumerate(bbox_result)
]
labels = np.concatenate(labels)
# mmcv.imshow_det_bboxes(
# img.copy(),
# bboxes,
# labels,
# class_names=class_names,
# score_thr=score_thr,
# show=out_file is None)
mmcv.imwrite(img, 'test1.jpg')
def process_img(args, dst_image_root, ignore_image_root, preserve_vertical,
split, format):
# Dirty hack for multi-processing
img_idx, img_info, anns = args
src_img = mmcv.imread(img_info['file_name'])
labels = []
for ann_idx, ann in enumerate(anns):
segmentation = []
for x, y in ann['points']:
segmentation.append(max(0, x))
segmentation.append(max(0, y))
xs, ys = segmentation[::2], segmentation[1::2]
x, y = min(xs), min(ys)
w, h = max(xs) - x, max(ys) - y
text_label = ann['transcription']
dst_img = src_img[y:y + h, x:x + w]
dst_img_name = f'img_{img_idx}_{ann_idx}.jpg'
if not preserve_vertical and h / w > 2 and split == 'train':
dst_img_path = osp.join(ignore_image_root, dst_img_name)
else:
dst_img_path = osp.join(dst_image_root, dst_img_name)
mmcv.imwrite(dst_img, dst_img_path)
if format == 'txt':
labels.append(f'{osp.basename(dst_image_root)}/{dst_img_name}'
f' {text_label}')
elif format == 'jsonl':
labels.append(
json.dumps({
'filename':
f'{osp.basename(dst_image_root)}/{dst_img_name}',
'text': text_label
}))
else:
raise NotImplementedError
return labels
def main():
""" Demo for video interpolation models.
Note that we accept video as input(output), when 'input_dir'('output_dir')
is set to the path to the video. But using videos introduces video
compression, which lower the visual quality. If you want actual quality,
please save them as separate images (.png).
"""
args = parse_args()
model = init_model(args.config,
args.checkpoint,
device=torch.device('cuda', args.device))
output, fps = video_interpolation_inference(model, args.input_dir,
args.start_idx, args.end_idx,
args.batch_size)
if args.fps_multiplier:
assert args.fps_multiplier > 0, '`fps_multiplier` cannot be negative'
assert fps > 0, 'the input is not a video'
fps = args.fps_multiplier * fps
else:
fps = args.fps if args.fps > 0 else fps
file_extension = os.path.splitext(args.output_dir)[1]
if file_extension in VIDEO_EXTENSIONS: # save as video
h, w = output[0].shape[:2]
fourcc = cv2.VideoWriter_fourcc(*'mp4v')
video_writer = cv2.VideoWriter(args.output_dir, fourcc, fps, (w, h))
for img in output:
video_writer.write(img)
cv2.destroyAllWindows()
video_writer.release()
else: # save as images
for i, img in enumerate(output):
save_path = f'{args.output_dir}/{args.filename_tmpl.format(i)}'
mmcv.imwrite(img, save_path)
def generate_ann(root_path, split, image_infos):
"""Generate cropped annotations and label txt file.
Args:
root_path (str): The relative path of the totaltext file
split (str): The split of dataset. Namely: training or test
image_infos (list[dict]): A list of dicts of the img and
annotation information
"""
dst_image_root = osp.join(root_path, 'dst_imgs', split)
if split == 'training':
dst_label_file = osp.join(root_path, 'train_label.txt')
elif split == 'test':
dst_label_file = osp.join(root_path, 'test_label.txt')
os.makedirs(dst_image_root, exist_ok=True)
lines = []
for image_info in image_infos:
index = 1
src_img_path = osp.join(root_path, 'imgs', image_info['file_name'])
image = mmcv.imread(src_img_path)
src_img_root = osp.splitext(image_info['file_name'])[0].split('/')[1]
for anno in image_info['anno_info']:
word = anno['word']
dst_img = crop_img(image, anno['bbox'])
# Skip invalid annotations
if min(dst_img.shape) == 0 or word == '###':
continue
dst_img_name = f'{src_img_root}_{index}.png'
index += 1
dst_img_path = osp.join(dst_image_root, dst_img_name)
mmcv.imwrite(dst_img, dst_img_path)
lines.append(f'{osp.basename(dst_image_root)}/{dst_img_name} '
f'{word}')
list_to_file(dst_label_file, lines)
def __call__(self, img, boxes, labels):
img = img.astype(np.float32)
##debug
DEGUG = False
if DEGUG:
global COUNT
image_before = img.copy()
for idx, bbox in enumerate(boxes):
image_before = visualize_bbox(image_before, bbox, labels[idx],
{1: 'positive'})
mmcv.imwrite(
image_before, "/home/wanglichao/mmdetection/output/img_" +
str(COUNT + 1) + "_before.jpg")
for transform in self.transforms:
img, boxes, labels = transform(img, boxes, labels)
##debug
boxes = np.array(boxes).astype(np.float32)
labels = np.array(labels).astype(np.int64)
if len(boxes.shape) == 1:
print("@" * 100)
boxes = np.expand_dims(boxes, axis=0)
if DEGUG:
print("\nafter", "*" * 50)
image_after = img.copy()
for idx, bbox in enumerate(boxes):
image_after = visualize_bbox(image_after, bbox, labels[idx],
{1: 'positive'})
mmcv.imwrite(
image_after, "/home/wanglichao/mmdetection/output/img_" +
str(COUNT + 1) + "_after.jpg")
COUNT = COUNT + 1
if COUNT > 20:
exit(1)
return img, boxes, labels
def dump_frames(vid_item):
full_path, vid_path, vid_id = vid_item
vid_name = vid_path.split('.')[0]
out_full_path = osp.join(args.out_dir, vid_name)
try:
os.mkdir(out_full_path)
except OSError:
pass
vr = mmcv.VideoReader(full_path)
video_length = 0
while vr.vcap.isOpened():
ret, frame = vr.vcap.read()
if ret:
mmcv.imwrite(frame, '{}/img_{:05d}.jpg'.format(out_full_path, video_length + 1))
else:
break
video_length += 1
print('{} done with {} frames'.format(vid_name, video_length))
sys.stdout.flush()
vr.vcap.release()
return True
def vis_combine(dir_a, dir_b, combine_dir, split_txt=None, alpha=None):
import itertools
from glob import glob
import mmcv
paths_a = glob(os.path.join(dir_a, '**', '*.jpg'), recursive=True)+glob(os.path.join(dir_a, '**', '*.png'), recursive=True)+glob(os.path.join(dir_a, '**', '*.jpeg'), recursive=True)
paths_b = []
for path_a in paths_a:
print(path_a)
if split_txt is not None:
name = path_a.split(split_txt)[-1]
else:
name = osp.basename(path_a)
path_b = osp.join(dir_b, name)
if not osp.exists(path_b):
path_b = path_b.replace('.png', '.jpg')
assert osp.exists(path_b), path_b
paths_b.append(path_b)
for pa, pb in zip(paths_a, paths_b):
if osp.basename(pa).split('.')[0]!=osp.basename(pb).split('.')[0]: continue
ima = mmcv.imread(pa)
h, w= ima.shape[:2]
imb = mmcv.imread(pb)
imb = mmcv.imresize(imb, (w,h))
if alpha is None:
imab = np.concatenate([ima, imb], 1)
else:
imab = (0.5*ima + 0.5*imb).astype('uint8')
# name = osp.basename(pa)
name = pa.split(split_txt)[-1]
out_path = osp.join(combine_dir, name)
mmcv.imwrite(imab, out_path)
def _save_image(meta, iteration, save_path, output):
"""Save the image.
Args:
meta (list[dict]): Meta data, such as path of target file.
Default: None. These dictionaries should contain
'target_path' (str of a path) or 'inputs_path' (list of str)
iteration (int): Iteration for the saving image name.
Default: None.
save_path (str): Path to save image. Default: None.
output (Tensor): Output image.
"""
if output.ndim == 4: # an image
img_name = meta[0]['key'].replace('/', '_')
if isinstance(iteration, numbers.Number):
save_path = osp.join(save_path,
f'{img_name}-{iteration + 1:06d}.png')
elif iteration is None:
save_path = osp.join(save_path, f'{img_name}.png')
else:
raise ValueError('iteration should be number or None, '
f'but got {type(iteration)}')
mmcv.imwrite(tensor2img(output), save_path)
elif output.ndim == 5: # a sequence
folder_name = meta[0]['key'].split('/')[0]
for i in range(0, output.size(1)):
if isinstance(iteration, numbers.Number):
save_path_i = osp.join(save_path, folder_name,
f'{i:08d}-{iteration + 1:06d}.png')
elif iteration is None:
save_path_i = osp.join(save_path, folder_name,
f'{i:08d}.png')
else:
raise ValueError('iteration should be number or None, '
f'but got {type(iteration)}')
mmcv.imwrite(tensor2img(output[:, i, :, :, :]), save_path_i)
def single_test(model, data_loader, cfg):
model.eval()
results = []
dataset = data_loader.dataset
prog_bar = mmcv.ProgressBar(len(dataset))
for i, data in enumerate(data_loader):
with torch.no_grad():
result, seg, img, meta = model(return_loss=False, **data)
#result = model(return_loss=False, **data)
#'''
for frame in range(8):
for idx_in_batch in range(seg.shape[0]):
seg0 = seg.argmax(1)[idx_in_batch, frame, :, :]
img0 = mmcv.imdenormalize(
img[idx_in_batch, :,
frame * 4, :, :].transpose([1, 2, 0]),
mean=np.array(cfg.img_norm_cfg.mean).reshape(1, 1, 3),
std=np.array(cfg.img_norm_cfg.std).reshape(1, 1, 3),
to_bgr=cfg.img_norm_cfg.to_rgb)
out_dir = os.path.join('outputs_ntucentercrop_1028',
meta[0]['img_path'],
'setting_%02d' % idx_in_batch)
if not os.path.isdir(out_dir):
os.makedirs(out_dir)
mmcv.imwrite(
img0, os.path.join(out_dir, 'img_%05d.png' % (frame)))
mmcv.imwrite(
seg0 * 255,
os.path.join(out_dir, 'seg_%05d.png' % (frame)))
#'''
results.append(result)
batch_size = data['img_group_0'].data[0].size(0)
for _ in range(batch_size):
prog_bar.update()
return results
def main():
parser = ArgumentParser()
parser.add_argument('img', help='Image file.')
parser.add_argument('config', help='Config file.')
parser.add_argument('checkpoint', help='Checkpoint file.')
parser.add_argument('out_file', help='Path to save visualized image.')
parser.add_argument('--device',
default='cuda:0',
help='Device used for inference.')
parser.add_argument('--imshow',
action='store_true',
help='Whether show image with OpenCV.')
args = parser.parse_args()
# build the model from a config file and a checkpoint file
model = init_detector(args.config, args.checkpoint, device=args.device)
if model.cfg.data.test['type'] == 'ConcatDataset':
model.cfg.data.test.pipeline = model.cfg.data.test['datasets'][
0].pipeline
# test a single image
result = model_inference(model, args.img)
print(f'result: {result}')
# show the results
img = model.show_result(args.img,
result,
out_file=args.out_file,
show=False)
if img is None:
img = mmcv.imread(args.img)
mmcv.imwrite(img, args.out_file)
if args.imshow:
mmcv.imshow(img, 'predicted results')
