def _match_to_lbl(self, proposals, bbx, cat, ids, msk, match): cls_lbl = [] bbx_lbl = [] msk_lbl = [] for i, (proposals_i, bbx_i, cat_i, ids_i, msk_i, match_i) in enumerate(zip(proposals, bbx, cat, ids, msk, match)): if match_i is not None: pos = match_i >= 0 # Objectness labels cls_lbl_i = proposals_i.new_zeros(proposals_i.size(0), dtype=torch.long) cls_lbl_i[pos] = cat_i[match_i[pos]] + 1 - self.num_stuff # Bounding box regression labels if pos.any().item(): bbx_lbl_i = calculate_shift(proposals_i[pos], bbx_i[match_i[pos]]) bbx_lbl_i *= bbx_lbl_i.new(self.bbx_reg_weights) iis_lbl_i = ids_i[match_i[pos]] # Compute instance segmentation masks msk_i = roi_sampling( msk_i.unsqueeze(0), proposals_i[pos], msk_i.new_zeros(pos.long().sum().item()), self.lbl_roi_size, #28*28 interpolation="nearest") # Calculate mask segmentation labels msk_lbl_i = (msk_i == iis_lbl_i.view( -1, 1, 1, 1)).any(dim=1).to(torch.long) if not self.void_is_background: msk_lbl_i[(msk_i == 0).all(dim=1)] = -1 else: bbx_lbl_i = None msk_lbl_i = None cls_lbl.append(cls_lbl_i) bbx_lbl.append(bbx_lbl_i) msk_lbl.append(msk_lbl_i) else: cls_lbl.append(None) bbx_lbl.append(None) msk_lbl.append(None) return PackedSequence(cls_lbl), PackedSequence( bbx_lbl), PackedSequence(msk_lbl)
def _rois(self, x, proposals, proposals_idx, img_size): stride = proposals.new( [fs / os for fs, os in zip(x.shape[-2:], img_size)]) proposals = (proposals - 0.5) * stride.repeat(2) + 0.5 return roi_sampling(x, proposals, proposals_idx, self.roi_size)
def save_prediction_image(raw_pred, img_info, out_dir, colors, num_stuff, threshold, obj_cls): bbx_pred, cls_pred, obj_pred, msk_pred = raw_pred img = Image.open(img_info["abs_path"]) draw = ImageDraw.Draw(img) # Prepare folders and paths folder, img_name = path.split(img_info["rel_path"]) img_name, _ = path.splitext(img_name) out_dir = path.join(out_dir, folder) ensure_dir(out_dir) out_path = path.join(out_dir, img_name + ".jpg") # Rescale bounding boxes scale_factor = [ os / bs for os, bs in zip(img_info["original_size"], img_info["batch_size"]) ] bbx_pred[:, [0, 2]] = bbx_pred[:, [0, 2]] * scale_factor[0] bbx_pred[:, [1, 3]] = bbx_pred[:, [1, 3]] * scale_factor[1] # Expand masks bbx_inv = invert_roi_bbx(bbx_pred, list(msk_pred.shape[-2:]), list(img_info["original_size"])) bbx_idx = torch.arange(0, msk_pred.size(0), dtype=torch.long) msk_pred = roi_sampling(msk_pred.cpu().unsqueeze(1).sigmoid(), bbx_inv.cpu(), bbx_idx, list(img_info["original_size"]), padding="zero") msk_pred = msk_pred.squeeze(1) > 0.5 print(type(msk_pred)) id = 1 for bbx_pred_i, cls_pred_i, obj_pred_i, msk_pred_i in zip( bbx_pred, cls_pred, obj_pred, msk_pred): color = colors[cls_pred_i.item() + num_stuff] if obj_pred_i.item() > threshold: if not obj_cls: # detect ALL msk = Image.fromarray(msk_pred_i.numpy() * 192) draw.bitmap((0, 0), msk, tuple(color)) draw.rectangle(( bbx_pred_i[1].item(), bbx_pred_i[0].item(), bbx_pred_i[3].item(), bbx_pred_i[2].item(), ), outline=tuple(color), width=3) if str(cls_pred_i.item()) == obj_cls: # detect specific class msk = Image.fromarray(msk_pred_i.numpy() * 192) draw.bitmap((0, 0), msk, tuple(color)) draw.rectangle(( bbx_pred_i[1].item(), bbx_pred_i[0].item(), bbx_pred_i[3].item(), bbx_pred_i[2].item(), ), outline=tuple(color), width=3) _dict = { 'id': id, 'bbox': { 'x1': bbx_pred_i[0].item(), 'y1': bbx_pred_i[1].item(), 'x2': bbx_pred_i[2].item(), 'y2': bbx_pred_i[3].item(), }, 'cls_pred': cls_pred_i.item(), 'obj_pred': obj_pred_i.item(), 'msk_pred': msk_pred_i.data.numpy(), } if not path.isdir(path.join(out_dir, img_name)): mkdir(path.join(out_dir, img_name)) np.save(path.join(out_dir, img_name + '/' + str(id)), _dict) id = id + 1 img.convert(mode="RGB").save(out_path)