def show_boxes(self, img, target):
bbox_np = target.bbox.data.cpu().numpy()
# print('image shape:', img.size())
np_img = np.transpose(np.uint8(img.data.cpu().numpy()), (1, 2, 0))
img_pil = Image.fromarray(np_img)
draw_img = vis_image(img_pil, bbox_np)
draw_img.save('gt_show.jpg', 'jpeg')
def prepare_targets(self, proposals, targets):
labels = []
regression_targets = []
high_discard_masks = []
for proposals_per_image, targets_per_image in zip(proposals, targets):
matched_targets = self.match_targets_to_proposals(
proposals_per_image, targets_per_image)
matched_idxs = matched_targets.get_field("matched_idxs")
labels_per_image = matched_targets.get_field("labels")
labels_per_image = labels_per_image.to(dtype=torch.int64)
# Label background (below the low threshold)
bg_inds = matched_idxs == Matcher.BELOW_LOW_THRESHOLD
labels_per_image[bg_inds] = 0
# Label ignore proposals (between low and high thresholds)
ignore_inds = matched_idxs == Matcher.BETWEEN_THRESHOLDS
labels_per_image[ignore_inds] = -1 # -1 is ignored by sampler
if self.discard_highest:
discard_inds = matched_idxs == Matcher.HIGER_HIGH_THRESHOLD
# <= -2 set the regression loss to 0.
# labels_per_image[discard_inds] = - (labels_per_image[discard_inds] + 1)
high_discard_mask = torch.ones_like(labels_per_image,
dtype=torch.uint8)
high_discard_mask[discard_inds] = 0
high_discard_masks.append(high_discard_mask)
# compute regression targets
regression_targets_per_image = self.box_coder.encode(
matched_targets.bbox, proposals_per_image.bbox)
if _DEBUG:
self.iter_cnt += 1
if self.iter_cnt % 10 == 0:
label_np = labels_per_image.data.cpu().numpy()
# print('label shape:', label_np.shape)
# print('labels pos/neg:', len(np.where(label_np == 1)[0]), '/', len(np.where(label_np == 0)[0]))
imw, imh = proposals_per_image.size
proposals_np = proposals_per_image.bbox.data.cpu().numpy()
canvas = np.zeros((imh, imw, 3), np.uint8)
# pick pos proposals for visualization
pos_proposals = proposals_np[label_np == 1]
# print('proposals_np:', pos_proposals)
pilcanvas = vis_image(
Image.fromarray(canvas), pos_proposals,
[i for i in range(pos_proposals.shape[0])])
pilcanvas.save('proposals_for_rcnn_maskboxes.jpg', 'jpeg')
# print('proposal target', regression_targets_per_image, np.unique(labels_per_image.data.cpu().numpy()))
# print('labels_per_image:', labels_per_image.size(), np.unique(label_np))
labels.append(labels_per_image)
regression_targets.append(regression_targets_per_image)
return labels, regression_targets, high_discard_masks
def show_boxes(self, img, target):
bbox_np = target.bbox.data.cpu().numpy()
# print('image shape:', img.size())
np_img = np.transpose(np.uint8(img.data.cpu().numpy()), (1, 2, 0))
img_pil = Image.fromarray(np_img)
# print('bbox_np:', bbox_np)
draw_img = vis_image(img_pil, bbox_np)
draw_img.save('gt_show.jpg', 'jpeg')
polys = target.get_field('masks')
# print('polys:', polys.polygons)
mask_gt = vis_masks(polys.polygons, img_pil.size)
mask_gt.save('gt_show_masks.jpg', 'jpeg')
def prepare_targets(self, proposals, targets):
labels = []
regression_targets = []
for proposals_per_image, targets_per_image in zip(proposals, targets):
matched_targets = self.match_targets_to_proposals(
proposals_per_image, targets_per_image
)
matched_idxs = matched_targets.get_field("matched_idxs")
labels_per_image = matched_targets.get_field("labels")
labels_per_image = labels_per_image.to(dtype=torch.int64)
# Label background (below the low threshold)
bg_inds = matched_idxs == Matcher.BELOW_LOW_THRESHOLD
labels_per_image[bg_inds] = 0
# Label ignore proposals (between low and high thresholds)
ignore_inds = matched_idxs == Matcher.BETWEEN_THRESHOLDS
labels_per_image[ignore_inds] = -1 # -1 is ignored by sampler
# compute regression targets
regression_targets_per_image = self.box_coder.encode(
matched_targets.bbox, proposals_per_image.bbox
)
if _DEBUG:
label_np = labels_per_image.data.cpu().numpy()
# print('label shape:', label_np.shape)
# print('labels pos/neg:', len(np.where(label_np == 1)[0]), '/', len(np.where(label_np == 0)[0]))
imw, imh = proposals_per_image.size
proposals_np = proposals_per_image.bbox.data.cpu().numpy()
canvas = np.zeros((imh, imw, 3), np.uint8)
# pick pos proposals for visualization
pos_proposals = proposals_np[label_np == 1]
# print('proposals_np:', pos_proposals)
pilcanvas = vis_image(Image.fromarray(canvas), pos_proposals)
pilcanvas.save('proposals_for_rcnn_1315.jpg', 'jpeg')
# print('proposal target', regression_targets_per_image, np.unique(labels_per_image.data.cpu().numpy()))
# print('labels_per_image:', labels_per_image.size(), np.unique(label_np))
labels.append(labels_per_image)
regression_targets.append(regression_targets_per_image)
return labels, regression_targets
tic = time.time()
predictions, bounding_boxes = coco_demo.run_on_opencv_image(img)
toc = time.time()
print('time cost:',
str(toc - tic)[:6], '|',
str(cnt) + '/' + str(num_images))
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
bboxes_np = bounding_boxes.bbox.data.cpu().numpy()
bboxes_np[:, 2:4] /= cfg.MODEL.RRPN.GT_BOX_MARGIN
width, height = bounding_boxes.size
if vis:
pil_image = vis_image(Image.fromarray(img), bboxes_np)
pil_image.show()
time.sleep(10)
write_result_ICDAR_RRPN2polys(image[:-4],
bboxes_np,
threshold=0.7,
result_dir=result_dir,
height=height,
width=width)
#im_file, dets, threshold, result_dir, height, width
#cv2.imshow('win', predictions)
#cv2.waitKey(0)
if dataset_name == 'IC15':
zipfilename = os.path.join(
result_dir, 'submit_' + config_file.split('/')[-1].split('.')[0] +
#########################################
toc = time.time()
print('time cost:',
str(toc - tic)[:6], '|',
str(cnt) + '/' + str(num_images))
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
box_res_rotate_np = np.array(box_res_rotate_)
##box_res_rotate_np[:, 2:4] /= cfg.MODEL.RRPN.GT_BOX_MARGIN #clw note:如果训练时没有用T.randomRotation,就不会扩边,那这里也不用除
width, height = bounding_boxes.size
if vis:
pil_image = vis_image(Image.fromarray(img),
box_res_rotate_np) # clw modify
pil_image.save(image)
#pil_image.show()
# time.sleep(1) # clw modify: 之前是10
else:
#write_result_ICDAR_RRPN2polys(image[:-4], bboxes_np, threshold=0.7, result_dir=result_dir, height=height, width=width)
# clw modify
# eval txt
CLASS_DOTA = NAME_LABEL_MAP.keys()
# Task1
write_handle_r = {}
txt_dir_r = './txt_output'
if not os.path.exists(txt_dir_r):
os.mkdir(txt_dir_r)
def prepare_targets(self,
level_objectness,
targets,
size_range=None,
scale=None,
level=-1,
boxes_reg=None):
labels = []
regression_targets = []
classmaps = []
N, C, H, W = level_objectness.shape
device = level_objectness.device
assert len(
size_range
) == 2, "size_range should be with left bound and right bound"
for targets_per_image, boxes_reg_per_image in zip(targets, boxes_reg):
# print("targets_per_image:", targets_per_image)
# targets_per_image = targets_per_image_[0]
with torch.no_grad():
rboxes = targets_per_image.bbox.data.cpu().numpy()
words_seq_np_ = targets_per_image.get_field(
"words").data.cpu().numpy()
words_len_np_ = targets_per_image.get_field(
"word_length").data.cpu().numpy()
box_areas = rboxes[:, 2] * rboxes[:, 3]
bound_all = box_areas >= size_range[0]
if size_range[1] != 0:
right_bound = box_areas < size_range[1]
bound_all = np.logical_and(bound_all, right_bound)
rboxes_cp = rboxes[bound_all]
words_seq_np = words_seq_np_[bound_all]
words_len_np = words_len_np_[bound_all]
word_seqs = []
for i in range(len(words_len_np)):
word_seqs.append(words_seq_np[i][:words_len_np[i]])
# print("rboxes:", rboxes_cp, size_range, box_areas)
box_in_4pts = rbox2poly(rboxes_cp)
# scale = 1 / np.rint(scale_w)
# print("rboxes_cp:", rboxes_cp)
# print("scale", scale)
# heatmap: (H * W, 1)
# target: (H * W, 4)
heatmap, regression_targets_per_image, classmap = make_target_rbox_mc(
(H, W),
scale,
box_in_4pts,
rboxes_cp,
word_seqs,
dense_ratio=0.7)
if DEBUG:
imW, imH = targets_per_image.size
if len(rboxes_cp) > 0:
# heatmap_np = heatmap.data.cpu().numpy()
# print("heatmap_np:", len(rboxes_cp), len(box_in_4pts), np.unique(heatmap))
heatmap_np = heatmap.reshape(H, W)
clsmap_np = classmap.reshape(H, W)
level_objectness_np = level_objectness.data.cpu(
).numpy()
level_objectness_np = level_objectness_np.reshape(H, W)
boxes_reg_per_image_np_ = boxes_reg_per_image.data.cpu(
).numpy()
class_map_logits = F.softmax(
boxes_reg_per_image[5:].permute(1, 2, 0),
dim=-1).data.cpu().numpy()
clsmap_prob = np.max(class_map_logits[..., 1:],
axis=-1)
boxes_reg_per_image_np = boxes_reg_per_image_np_[:5]
print(
"boxes_reg_per_image_np:",
class_map_logits.shape,
boxes_reg_per_image_np.shape,
level_objectness_np.shape,
regression_targets_per_image.shape,
clsmap_prob.shape,
# np.unique(classmap),
# np.unique(heatmap_np),
# np.unique(clsmap_prob)[-10:]
)
# boxes_reg_per_image_np = boxes_reg_per_image_np.reshape(-1, 5)
cv2.imwrite("clsmap_prob_level_" + str(level) + ".jpg",
((clsmap_prob > 0.3) * 255).astype(
np.uint8))
cv2.imwrite("heatmap_level_" + str(level) + ".jpg",
((heatmap_np > 0.7) * 255).astype(
np.uint8))
cv2.imwrite("clsmap_level_" + str(level) + ".jpg",
((clsmap_np) * 3).astype(np.uint8))
cv2.imwrite("objectness_level_" + str(level) + ".jpg",
((level_objectness_np > 0.7) * 255).astype(
np.uint8))
regression_targets_per_image_np = regression_targets_per_image.reshape(
1, -1, 5).copy()
label = heatmap_np.reshape(-1) == 1
# regression_targets_per_image_np = regression_targets_per_image_np.reshape(1, -1, 5)
regression_targets_per_image_np[
..., -1] = regression_targets_per_image_np[
..., -1] / 3.14159265358979 * 2 + 0.5
gt_rboxes = eastbox2rbox_np(
regression_targets_per_image_np, 1, (H, W), scale)
boxes_reg_per_image_np = np.transpose(
boxes_reg_per_image_np,
(1, 2, 0)).reshape(1, -1, 5)
picked_sig = boxes_reg_per_image_np.reshape(
-1, 5)[label][..., -1]
# print("picked_sig:", np.unique(picked_sig[-5:]))
proposals = eastbox2rbox_np(boxes_reg_per_image_np,
self.base_size, (H, W),
scale)
gt_rboxes = gt_rboxes.reshape(-1, 5)[label]
proposals = proposals.reshape(-1, 5)[label]
# boxes_reg_per_image_np = boxes_reg_per_image_np.reshape(-1, 5)[label]
# regression_targets_per_image_np = regression_targets_per_image_np.reshape(-1, 5)[label]
# print("recover:", gt_rboxes)
# print("proposals angle:", np.unique(proposals[:, -1][-5:]), np.unique(gt_rboxes[:, -1][-5:]))
# print("x, y gt pred:", gt_rboxes[:10][:, :4], proposals[:10][:, :4])
# print("t, r, n, l gt pred:", regression_targets_per_image_np[:10][:, :4], boxes_reg_per_image_np[:10][:, :4] * 640.)
canvas = np.zeros((imH, imW, 3)).astype(np.uint8)
canvas = Image.fromarray(canvas)
canvas = vis_image(canvas, gt_rboxes, mode=1)
canvas = vis_image(canvas, proposals, mode=2)
canvas.save("level_" + str(level) + "_boxes.jpg")
pass
heatmap = torch.tensor(heatmap).to(device).float()
classmap = torch.tensor(classmap).to(device).float()
regression_targets_per_image = torch.tensor(
regression_targets_per_image).to(device).float()
# print("heatmap:", heatmap.shape, regression_targets_per_image.shape)
labels.append(heatmap[None, ...])
regression_targets.append(regression_targets_per_image[None, ...])
classmaps.append(classmap[None, ...])
return torch.cat(labels, dim=0), torch.cat(regression_targets,
dim=0), torch.cat(classmaps,
dim=0)
def gotest(setting_weights, config_file, remove_output_dir=False):
# config_file = "configs/arpn/e2e_rrpn_R_50_C4_1x_train_AFPN_RT.yaml" #'configs/rrpn/e2e_rrpn_R_50_C4_1x_LSVT_test_RFPN.yaml' #'#"configs/ICDAR2019_det_RRPN/e2e_rrpn_R_50_C4_1x_LSVT_val_4scales_angle_norm.yaml" #e2e_rrpn_R_50_C4_1x_ICDAR13_15_trial_test.yaml
# update the config options with the config file
cfg.merge_from_file(config_file)
# manual override some options
cfg.merge_from_list(["MODEL.DEVICE", "cuda"])
if remove_output_dir:
cfg.merge_from_list(["OUTPUT_DIR", ""])
opts = ["MODEL.WEIGHT", setting_weights]
cfg.merge_from_list(opts)
# cfg.MODEL.WEIGHT = setting_weights
# cfg.freeze()
vis = True
merge_box = cfg.TEST.MERGE_BOX
result_dir = os.path.join('results',
config_file.split('/')[-1].split('.')[0],
cfg.MODEL.WEIGHT.split('/')[-1].split('.')[0])
if merge_box:
result_dir += '_merge_box'
if not os.path.isdir(result_dir):
os.makedirs(result_dir)
else:
print(os.popen("rm -rf " + result_dir).read())
os.makedirs(result_dir)
coco_demo = RRPNDemo(
cfg,
min_image_size=1260,
confidence_threshold=0.4,
)
#
dataset_name = cfg.TEST.DATASET_NAME
print("dataset_name:", dataset_name)
testing_dataset = {
'LSVT': {
'testing_image_dir':
'../datasets/LSVT/train_full_images_0/train_full_images_0/',
'off': [0, 3000]
},
'ArT': {
'testing_image_dir':
'../datasets/ArT/ArT_detect_train/train_images',
'off': [4000, 5603]
},
'ReCTs': {
'testing_image_dir': '',
'off': [0, 1000000]
},
'MLT': {
'testing_image_dir': '/mnt/nvme/Dataset/MLT/val/image/',
'off': [0, 1000000]
},
'MLT_test': {
'testing_image_dir': [
'/mnt/nvme/Dataset/MLT/test/MLT19_TestImagesPart1/TestImagesPart1',
'/mnt/nvme/Dataset/MLT/test/MLT19_TestImagesPart2/TestImagesPart2'
],
'off': [0, 1000000]
},
'IC15': {
'testing_image_dir': '../dataset/ICDAR15/ch4_test_images/',
'off': [0, 500],
'gt_dir': "../dataset/ICDAR15/Challenge4_Test_Task4_GT"
},
'docVQA': {
'testing_image_dir':
'../dataset/docVQA/docvqa_train_v0.1/documents/',
'off': [4000, 4330],
# 'gt_dir':"../dataset/ICDAR15/Challenge4_Test_Task4_GT"
},
'docVQA_TEST': {
'testing_image_dir': '../dataset/docVQA/test/documents/',
'off': [0, 1000000] # [4000, 4330],
# 'gt_dir':"../dataset/ICDAR15/Challenge4_Test_Task4_GT"
},
'docVQA_VAL': {
'testing_image_dir': '../dataset/docVQA/val/documents/',
'off': [0, 1000000]
}
}
image_dir = testing_dataset[dataset_name]['testing_image_dir']
# vocab_dir = testing_dataset[dataset_name]['test_vocal_dir']
off_group = testing_dataset[dataset_name]['off']
# load image and then run prediction
# image_dir = '../datasets/ICDAR13/Challenge2_Test_Task12_Images/'
# imlist = os.listdir(image_dir)[off_group[0]:off_group[1]]
image_vis_dir = "vis_results_" + dataset_name + "/"
if not os.path.isdir(image_vis_dir):
os.makedirs(image_vis_dir)
print('************* META INFO ***************')
print('config_file:', config_file)
print('result_dir:', result_dir)
print('image_dir:', image_dir)
print('weights:', cfg.MODEL.WEIGHT)
print('merge_box:', merge_box)
print('***************************************')
imlist = []
if type(image_dir) == list:
for dir in image_dir:
tmp_list = os.listdir(dir)
for im_name in tmp_list:
imlist.append(os.path.join(dir, im_name))
else:
imlist = os.listdir(image_dir)
imlist.sort()
num_images = len(imlist)
cnt = 0
if dataset_name in ['ReCTs', 'MLT']:
for image in imlist:
# image = 'gt_' + str(idx) + '.jpg'
if type(image_dir) == list:
impath = image
else:
impath = os.path.join(image_dir, image)
# print('image:', impath)
img = cv2.imread(impath)
cnt += 1
tic = time.time()
predictions, bounding_boxes = coco_demo.run_on_opencv_image(img)
toc = time.time()
print('time cost:',
str(toc - tic)[:6], '|',
str(cnt) + '/' + str(num_images))
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
bboxes_np = bounding_boxes.bbox.data.cpu().numpy()
# bboxes_np[:, 2:4] /= cfg.MODEL.RRPN.GT_BOX_MARGIN
if merge_box:
bboxes_np_reverse = bboxes_np.copy()
bboxes_np_reverse[:, 2:4] = bboxes_np_reverse[:, 3:1:-1]
bboxes_np_reverse = merge(bboxes_np_reverse)
bboxes_np_reverse[:, 2:4] = bboxes_np_reverse[:, 3:1:-1]
bboxes_np = bboxes_np_reverse
width, height = bounding_boxes.size
if vis:
pil_image = vis_image(Image.fromarray(img), bboxes_np)
# pil_image.show()
# time.sleep(20)
else:
results_prefix = image[:-4].replace(
'tr_', '') if dataset_name == 'MLT' else image[:-4]
write_result_ICDAR_RRPN2polys(results_prefix,
bboxes_np,
threshold=0.7,
result_dir=result_dir,
height=height,
width=width)
# im_file, dets, threshold, result_dir, height, width
# cv2.imshow('win', predictions)
# cv2.waitKey(0)
else:
num_images = min(off_group[1], len(imlist)) - off_group[0]
for idx in range(off_group[0], min(off_group[1], len(imlist))):
if dataset_name == "IC15":
image = 'img_' + str(idx + 1) + '.jpg' #idx
else:
image = imlist[idx]
impath = os.path.join(image_dir, image)
# print('image:', impath)
img = cv2.imread(impath)
# img = padding32(img)
cnt += 1
tic = time.time()
predictions, bounding_boxes = coco_demo.run_on_opencv_image(img)
toc = time.time()
print('time cost:',
str(toc - tic)[:6], '|',
str(cnt) + '/' + str(num_images), image)
bboxes_np = bounding_boxes.bbox.data.cpu().numpy()
# bboxes_np[:, 2:4] /= cfg.MODEL.RRPN.GT_BOX_MARGIN
# bboxes_np[:, :2] = bboxes_np[:, :2] - 16.
if merge_box:
bboxes_np_reverse = bboxes_np.copy()
bboxes_np_reverse[:, 2:4] = bboxes_np_reverse[:, 3:1:-1]
bboxes_np_reverse = merge(bboxes_np_reverse)
bboxes_np_reverse[:, 2:4] = bboxes_np_reverse[:, 3:1:-1]
bboxes_np = bboxes_np_reverse
width, height = bounding_boxes.size
scores = bounding_boxes.get_field("scores").data.cpu().numpy()
if bboxes_np.shape[0] > 0:
# merge_keep = merge_closest(bboxes_np, scores, 0.81)
# bboxes_np = bboxes_np[merge_keep]
# scores = scores[merge_keep]
pass
if vis:
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
pil_image = Image.fromarray(img)
# print("bboxes_np:", bboxes_np)
if "gt_dir" in testing_dataset[dataset_name]:
gt_file = os.path.join(
testing_dataset[dataset_name]["gt_dir"],
"gt_" + image.split(".")[0] + ".txt")
gt_lines = open(gt_file, "r").readlines()
gt_boxes = []
for line in gt_lines:
splts = line.replace("\r", "").replace("\n",
"").split(",")
if len(splts) > 8:
gt_boxes.append(
np.array(splts[:8]).astype(np.int32))
pil_image = vis_image(pil_image,
np.array(gt_boxes),
mode=1,
repre="poly")
# gt_image.save(os.path.join(image_vis_dir, "gt_" + image))
pil_image = vis_image(pil_image, bboxes_np, mode=2)
pil_image.save(os.path.join(image_vis_dir, image))
# cv2.imwrite(os.path.join(image_vis_dir, "mask_" + image), predictions)
# pil_image.show()
# time.sleep(20)
# else:
# print("bboxes_np", bboxes_np.shape)
write_result_ICDAR_RRPN2polys(image[:-4],
bboxes_np,
threshold=0.7,
result_dir=result_dir,
height=height,
width=width)
#im_file, dets, threshold, result_dir, height, width
# print("predictions:", predictions.shape)
# cv2.imshow('win', predictions)
# cv2.waitKey(0)
del coco_demo
if dataset_name == 'IC15':
zipfilename = os.path.join(
result_dir, 'submit_' + config_file.split('/')[-1].split('.')[0] +
'_' + cfg.MODEL.WEIGHT.split('/')[-1].split('.')[0] + '.zip')
if os.path.isfile(zipfilename):
print('Zip file exists, removing it...')
os.remove(zipfilename)
zip_dir(result_dir, zipfilename)
comm = 'curl -i -F "submissionFile=@' + zipfilename + '" http://127.0.0.1:8080/evaluate'
print(comm)
print(os.popen(comm, 'r'))
res_dict = compute_hmean(zipfilename)
del res_dict["per_sample"]
print(res_dict)
return res_dict
elif dataset_name == 'MLT':
zipfilename = os.path.join(
result_dir, 'submit_' + config_file.split('/')[-1].split('.')[0] +
'_' + cfg.MODEL.WEIGHT.split('/')[-1].split('.')[0] + '.zip')
if os.path.isfile(zipfilename):
print('Zip file exists, removing it...')
os.remove(zipfilename)
zip_dir(result_dir, zipfilename)
comm = 'curl -i -F "submissionFile=@' + zipfilename + '" http://127.0.0.1:8080/evaluate'
# print(comm)
print(os.popen(comm, 'r'))
elif dataset_name == 'LSVT':
# input_json_path = 'results/e2e_rrpn_R_50_C4_1x_LSVT_val/model_0190000/res.json'
gt_json_path = '../datasets/LSVT/train_full_labels.json'
# to json
input_json_path = res2json(result_dir)
eval_func(input_json_path, gt_json_path)
elif dataset_name == 'ArT':
# input_json_path = 'results/e2e_rrpn_R_50_C4_1x_LSVT_val/model_0190000/res.json'
gt_json_path = '../datasets/ArT/ArT_detect_train/train_labels.json'
# to json
input_json_path = res2json(result_dir)
eval_func(input_json_path, gt_json_path)
else:
pass
return None
def prepare_targets(self, proposals, targets, batch_idx):
labels = []
regression_targets = []
for proposals_per_image, targets_per_image, batch_id in zip(
proposals, targets, batch_idx):
matched_targets = self.match_targets_to_proposals(
proposals_per_image, targets_per_image)
matched_idxs = matched_targets.get_field("matched_idxs")
labels_per_image = matched_targets.get_field("labels")
labels_per_image = labels_per_image.to(dtype=torch.int64)
# Label background (below the low threshold)
bg_inds = matched_idxs == Matcher.BELOW_LOW_THRESHOLD
labels_per_image[bg_inds] = 0
# Label ignore proposals (between low and high thresholds)
ignore_inds = matched_idxs == Matcher.BETWEEN_THRESHOLDS
labels_per_image[ignore_inds] = -1 # -1 is ignored by sampler
# compute regression targets
##################################
#print("this is matched target box")
#print(matched_targets.bbox)
#print("this is proposal per image box")
#print(proposals_per_image.bbox)
###################################
regression_targets_per_image = self.box_coder.encode_ori_rel(
matched_targets.bbox, proposals_per_image.bbox)
#relative
if _DEBUG:
label_np = labels_per_image.data.cpu().numpy()
# print('label shape:', label_np.shape)
# print('labels pos/neg:', len(np.where(label_np == 1)[0]), '/', len(np.where(label_np == 0)[0]))
imh, imw = proposals_per_image.size
proposals_np = proposals_per_image.bbox.data.cpu().numpy()
canvas = np.zeros((imh, imw, 3), np.uint8)
# pick pos proposals for visualization
pos_proposals = proposals_np[label_np == 1]
print(pos_proposals)
#pos_proposals = proposals_np[label_np == 1]
# print('proposals_np:', pos_proposals)
pos_proposals[:, 0] = (pos_proposals[:, 0]) * 175 / 70.4 + 0.5
pos_proposals[:, 1] = (pos_proposals[:, 1] +
40.0) * 199 / 80.0 + 0.5
pos_proposals[:, 3] = (pos_proposals[:, 3]) * 175 / 70.4
pos_proposals[:, 4] = (pos_proposals[:, 4]) * 199 / 80.0
pilcanvas = vis_image(
Image.fromarray(canvas), pos_proposals[:, [0, 1, 3, 4, 6]],
[i for i in range(pos_proposals.shape[0])])
print(batch_id)
pilcanvas.show()
pilcanvas.save('proposalmaskboxes.jpg', 'jpeg')
# print('proposal target', regression_targets_per_image, np.unique(labels_per_image.data.cpu().numpy()))
# print('labels_per_image:', labels_per_image.size(), np.unique(label_np))
#print("label per image")
#print(labels_per_image.size(), labels_per_image)
#print("regression target per image")
#print(regression_targets_per_image.size(), regression_targets_per_image)
labels.append(labels_per_image)
regression_targets.append(regression_targets_per_image)
return labels, regression_targets