def run_check_dataset_reader():
def augment(image, multi_mask, meta, index):
box, label, instance = multi_mask_to_annotation(multi_mask)
return image, multi_mask, box, label, instance, meta, index
dataset = ScienceDataset(
'train1_ids_gray2_500',
mode='train',
#'disk0_ids_dummy_9', mode='train',
#'merge1_1', mode='train',
transform=augment,
)
#sampler = SequentialSampler(dataset)
sampler = RandomSampler(dataset)
for n in iter(sampler):
#for n in range(10):
#n=0
#while 1:
image, multi_mask, box, label, instance, meta, index = dataset[n]
print('n=%d------------------------------------------' % n)
print('meta : ', meta)
contour_overlay = multi_mask_to_contour_overlay(multi_mask,
image,
color=[0, 0, 255])
color_overlay = multi_mask_to_color_overlay(multi_mask)
image_show('image', np.hstack([image, color_overlay, contour_overlay]))
num_masks = len(instance)
for i in range(num_masks):
x0, y0, x1, y1 = box[i]
print('label[i], box[i] : ', label[i], box[i])
instance1 = cv2.cvtColor((instance[i] * 255).astype(np.uint8),
cv2.COLOR_GRAY2BGR)
image1 = image.copy()
color_overlay1 = color_overlay.copy()
contour_overlay1 = contour_overlay.copy()
cv2.rectangle(instance1, (x0, y0), (x1, y1), (0, 255, 255), 2)
cv2.rectangle(image1, (x0, y0), (x1, y1), (0, 255, 255), 2)
cv2.rectangle(color_overlay1, (x0, y0), (x1, y1), (0, 255, 255), 2)
cv2.rectangle(contour_overlay1, (x0, y0), (x1, y1), (0, 255, 255),
2)
image_show(
'instance[i]',
np.hstack(
[instance1, image1, color_overlay1, contour_overlay1]))
cv2.waitKey(0)
def run_check_dataset_reader():
def augment(image, multi_mask, index):
box, label, instance = multi_mask_to_annotation(multi_mask)
# for display
multi_mask = multi_mask / multi_mask.max() * 255
count = len(instance)
instance_gray = instance.copy()
instance = []
for i in range(count):
instance.append(
cv2.cvtColor((instance_gray[i] * 255).astype(np.uint8),
cv2.COLOR_GRAY2BGR))
instance = np.array(instance)
return image, multi_mask, box, label, instance, index
dataset = ScienceDataset(
'train1_ids_gray_only1_500',
mode='train',
transform=augment,
)
sampler = SequentialSampler(dataset)
# sampler = RandomSampler(dataset)
for n in iter(sampler):
# for n in range(10):
# n=0
# while 1:
image, multi_mask, box, label, instance, index = dataset[n]
image_show('image', image)
image_show('multi_mask', multi_mask)
count = len(instance)
for i in range(count):
x0, y0, x1, y1 = box[i]
cv2.rectangle(instance[i], (x0, y0), (x1, y1), (0, 0, 255), 1)
image_show('instance[i]', instance[i])
print('label[i], box[i] : ', label[i], box[i])
cv2.waitKey(1)
def run_check_run_length_decode():
name = 'b98681c74842c4058bd2f88b06063731c26a90da083b1ef348e0ec734c58752b'
npy_file = DATA_DIR + '/image/stage1_train/' + name + '/multi_mask.npy'
multi_mask = np.load(npy_file)
H, W = multi_mask.shape[:2]
cvs_EncodedPixels = []
num = int(multi_mask.max())
for m in range(num):
rle = run_length_encode(multi_mask == m + 1)
cvs_EncodedPixels.append(rle)
#reference encoding from 'stage1_train_labels.csv'
df = pd.read_csv(DATA_DIR + '/__download__/stage1_train_labels.csv')
df = df.loc[df['ImageId'] == name]
reference_cvs_EncodedPixels = df['EncodedPixels'].values
reference_cvs_EncodedPixels.sort()
reference_multi_mask = np.zeros((H, W), np.int32)
for rle in reference_cvs_EncodedPixels:
thresh = run_length_decode(rle, H, W, fill_value=255)
id = cvs_EncodedPixels.index(rle)
reference_multi_mask[thresh > 128] = id + 1
reference_multi_mask = reference_multi_mask.astype(np.float32)
reference_multi_mask = reference_multi_mask / reference_multi_mask.max() * 255
multi_mask = multi_mask.astype(np.float32)
multi_mask = multi_mask / multi_mask.max() * 255
print((reference_multi_mask != multi_mask).sum())
image_show('multi_mask', multi_mask, 2)
image_show('reference_multi_mask', reference_multi_mask, 2)
image_show('diff', (reference_multi_mask != multi_mask) * 255, 2)
cv2.waitKey(0)
def debug_and_draw(net,
inputs,
truth_boxes,
truth_labels,
truth_instances,
mode='test'):
mode0 = net.mode
net.set_mode(mode)
if mode in ['test']:
inputs = Variable(inputs.data, volatile=True).cuda()
net(inputs)
elif mode in ['train', 'valid']:
net(inputs, truth_boxes, truth_labels, truth_instances)
# loss = net.loss( inputs, truth_boxes, truth_labels, truth_instances )
#
# net( tensors, labels, gt_boxes )
# =====================================================
batch_size, C, H, W = inputs.size()
images = inputs.data.cpu().numpy()
rpn_probs_flat = net.rpn_probs_flat.data.cpu().numpy()
rpn_deltas_flat = net.rpn_deltas_flat.data.cpu().numpy()
windows = net.rpn_windows
proposals = net.rpn_proposals.data.cpu().numpy()
detections = net.detections
masks = net.masks
# print('train',batch_size)
for b in range(batch_size):
image = (images[b].transpose((1, 2, 0)) * 255).astype(np.uint8)
image = np.clip(image.astype(np.float32) * 2.5, 0,
255) # improve contrast
contour_overlay = image.copy()
label = truth_labels[b]
prob = rpn_probs_flat[b]
delta = rpn_deltas_flat[b]
image_rpn_proposal_before_nms = draw_rpn_proposal_before_nms(
image, prob, delta, windows, 0.95)
proposal = proposals[np.where(proposals[:, 0] == b)]
image1 = image.copy() # draw_label_as_gt_boxes(image, label)
image_rpn_proposal_after_nms = draw_rpn_proposal_after_nms(image1,
proposal,
top=100000)
detection = detections[b]
image_rcnn_detection_nms = draw_rcnn_detection_nms(image,
detection,
threshold=0.5)
# print(len(detection))
multi_mask = masks[b]
multi_mask_overlay = multi_mask_to_overlay(multi_mask)
num_masks = int(multi_mask.max())
for n in range(num_masks):
thresh = multi_mask == n
contour = thresh_to_inner_contour(thresh)
contour = contour.astype(np.float32) * 0.5
contour_overlay = contour[:, :, np.newaxis] * np.array(
(0, 255,
0)) + (1 - contour[:, :, np.newaxis]) * contour_overlay
# image_show('mask',mask/mask.max()*255,2)
all = np.hstack(
(image, image_rpn_proposal_before_nms,
image_rpn_proposal_after_nms, image_rcnn_detection_nms,
multi_mask_overlay, contour_overlay))
# cv2.imwrite(out_dir +'/train/%05d.png'%indices[b],all)
image_show('all', all, 2)
cv2.waitKey(0)
net.set_mode(mode0)
def run_train():
out_dir = RESULTS_DIR
initial_checkpoint = RESULTS_DIR / ' 00072200_model.pth'
#
pretrain_file = None # imagenet pretrain
## setup -----------------
(out_dir / 'checkpoint').mkdir(exist_ok=True)
(out_dir / 'train').mkdir(exist_ok=True)
(out_dir / 'backup').mkdir(exist_ok=True)
backup_project_as_zip(
PROJECT_PATH,
str(out_dir / 'backup' / ' code.train.%s.zip') % IDENTIFIER)
log = Logger()
log.open(out_dir + '/log.train.txt', mode='a')
log.write('\n--- [START %s] %s\n\n' % (IDENTIFIER, '-' * 64))
log.write('** some experiment setting **\n')
log.write('\tSEED = %u\n' % SEED)
log.write('\tPROJECT_PATH = %s\n' % PROJECT_PATH)
log.write('\tout_dir = %s\n' % out_dir)
log.write('\n')
## net ----------------------
log.write('** net setting **\n')
cfg = Configuration()
net = MaskRcnnNet(cfg).cuda()
if initial_checkpoint is not None:
log.write('\tinitial_checkpoint = %s\n' % initial_checkpoint)
net.load_state_dict(
torch.load(initial_checkpoint,
map_location=lambda storage, loc: storage))
elif pretrain_file is not None:
log.write('\tpretrained_file = %s\n' % pretrain_file)
# load_pretrain_file(net, pretrain_file)
log.write('%s\n\n' % (type(net)))
log.write('\n')
## optimiser ----------------------------------
iter_accum = 1
batch_size = 4 ##NUM_CUDA_DEVICES*512 #256//iter_accum #512 #2*288//iter_accum
num_iters = 1000 * 1000
iter_smooth = 20
iter_log = 50
iter_valid = 100
iter_save = [0, num_iters - 1] \
+ list(range(0, num_iters, 100)) # 1*1000
LR = None # LR = StepLR([ (0, 0.01), (200, 0.001), (300, -1)])
optimizer = SGD(filter(lambda p: p.requires_grad, net.parameters()),
lr=0.001 / iter_accum,
momentum=0.9,
weight_decay=0.0001)
start_iter = 0
start_epoch = 0.
if initial_checkpoint is not None:
checkpoint = torch.load(
initial_checkpoint.replace('_model.pth', '_optimizer.pth'))
start_iter = checkpoint['iter']
start_epoch = checkpoint['epoch']
# optimizer.load_state_dict(checkpoint['optimizer'])
## dataset ----------------------------------------
log.write('** dataset setting **\n')
train_dataset = ScienceDataset(
# 'train1_ids_gray_only1_500', mode='train',
'valid1_ids_gray_only1_43',
mode='train',
transform=train_augment)
train_loader = DataLoader(
train_dataset,
sampler=RandomSampler(train_dataset),
# sampler = ConstantSampler(train_dataset,list(range(16))),
batch_size=batch_size,
drop_last=True,
num_workers=4,
pin_memory=True,
collate_fn=train_collate)
valid_dataset = ScienceDataset(
'valid1_ids_gray_only1_43',
mode='train',
# 'debug1_ids_gray_only1_10', mode='train',
transform=valid_augment)
valid_loader = DataLoader(valid_dataset,
sampler=SequentialSampler(valid_dataset),
batch_size=batch_size,
drop_last=False,
num_workers=4,
pin_memory=True,
collate_fn=train_collate)
log.write('\ttrain_dataset.split = %s\n' % (train_dataset.split))
log.write('\tvalid_dataset.split = %s\n' % (valid_dataset.split))
log.write('\tlen(train_dataset) = %d\n' % (len(train_dataset)))
log.write('\tlen(valid_dataset) = %d\n' % (len(valid_dataset)))
log.write('\tlen(train_loader) = %d\n' % (len(train_loader)))
log.write('\tlen(valid_loader) = %d\n' % (len(valid_loader)))
log.write('\tbatch_size = %d\n' % (batch_size))
log.write('\titer_accum = %d\n' % (iter_accum))
log.write('\tbatch_size*iter_accum = %d\n' % (batch_size * iter_accum))
log.write('\n')
# log.write(inspect.getsource(train_augment)+'\n')
# log.write(inspect.getsource(valid_augment)+'\n')
# log.write('\n')
if 0: # <debug>
for inputs, truth_boxes, truth_labels, truth_instances, indices in valid_loader:
batch_size, C, H, W = inputs.size()
print(batch_size)
images = inputs.cpu().numpy()
for b in range(batch_size):
image = (images[b].transpose((1, 2, 0)) * 255)
image = np.clip(image.astype(np.float32) * 3, 0, 255)
image1 = image.copy()
truth_box = truth_boxes[b]
truth_label = truth_labels[b]
truth_instance = truth_instances[b]
if truth_box is not None:
for box, label, instance in zip(truth_box, truth_label,
truth_instance):
x0, y0, x1, y1 = box.astype(np.int32)
cv2.rectangle(image, (x0, y0), (x1, y1), (0, 0, 255),
1)
print(label)
thresh = instance > 0.5
contour = thresh_to_inner_contour(thresh)
contour = contour.astype(np.float32) * 0.5
image1 = contour[:, :, np.newaxis] * np.array(
(0, 255,
0)) + (1 - contour[:, :, np.newaxis]) * image1
print('')
image_show('image', image)
image_show('image1', image1)
cv2.waitKey(0)
## start training here! ##############################################
log.write('** start training here! **\n')
log.write(' optimizer=%s\n' % str(optimizer))
log.write(' momentum=%f\n' % optimizer.param_groups[0]['momentum'])
log.write(' LR=%s\n\n' % str(LR))
log.write(' images_per_epoch = %d\n\n' % len(train_dataset))
log.write(
' rate iter epoch num | valid_loss | train_loss | batch_loss | time \n'
)
log.write(
'------------------------------------------------------------------------------------------------------------------------------------------------------------------\n'
)
train_loss = np.zeros(6, np.float32)
train_acc = 0.0
valid_loss = np.zeros(6, np.float32)
valid_acc = 0.0
batch_loss = np.zeros(6, np.float32)
batch_acc = 0.0
rate = 0
start = time.time()
j = 0
i = 0
while i < num_iters: # loop over the dataset multiple times
sum_train_loss = np.zeros(6, np.float32)
sum_train_acc = 0.0
sum = 0
net.set_mode('train')
optimizer.zero_grad()
for inputs, truth_boxes, truth_labels, truth_instances, indices in train_loader:
batch_size = len(indices)
i = j / iter_accum + start_iter
epoch = (i - start_iter) * batch_size * iter_accum / len(
train_dataset) + start_epoch
num_products = epoch * len(train_dataset)
if i % iter_valid == 0:
net.set_mode('valid')
valid_loss, valid_acc = evaluate(net, valid_loader)
net.set_mode('train')
print('\r', end='', flush=True)
log.write(
'%0.4f %5.1f k %6.2f %4.1f m | %0.3f %0.2f %0.2f %0.2f %0.2f %0.2f | %0.3f %0.2f %0.2f %0.2f %0.2f %0.2f | %0.3f %0.2f %0.2f %0.2f %0.2f %0.2f | %s\n' % ( \
rate, i / 1000, epoch, num_products / 1000000,
valid_loss[0], valid_loss[1], valid_loss[2], valid_loss[3], valid_loss[4], valid_loss[5],
# valid_acc,
train_loss[0], train_loss[1], train_loss[2], train_loss[3], train_loss[4], train_loss[5],
# train_acc,
batch_loss[0], batch_loss[1], batch_loss[2], batch_loss[3], batch_loss[4], batch_loss[5],
# batch_acc,
time_to_str((time.time() - start) / 60)))
time.sleep(0.01)
# if 1:
if i in iter_save:
torch.save(net.state_dict(),
out_dir + '/checkpoint/%08d_model.pth' % (i))
torch.save(
{
'optimizer': optimizer.state_dict(),
'iter': i,
'epoch': epoch,
}, out_dir + '/checkpoint/%08d_optimizer.pth' % (i))
# learning rate schduler -------------
if LR is not None:
lr = LR.get_rate(i)
if lr < 0: break
adjust_learning_rate(optimizer, lr / iter_accum)
rate = get_learning_rate(optimizer)[0] * iter_accum
# one iteration update -------------
inputs = Variable(inputs).cuda()
net(inputs, truth_boxes, truth_labels, truth_instances)
loss = net.loss(inputs, truth_boxes, truth_labels, truth_instances)
if 1: # <debug>
debug_and_draw(net,
inputs,
truth_boxes,
truth_labels,
truth_instances,
mode='test')
# masks = (probs>0.5).float()
# acc = dice_loss(masks, labels)
# accumulated update
loss.backward()
if j % iter_accum == 0:
# torch.nn.utils.clip_grad_norm(net.parameters(), 1)
optimizer.step()
optimizer.zero_grad()
# print statistics ------------
batch_acc = 0 # acc[0][0]
batch_loss = np.array((
loss.cpu().data.numpy()[0],
net.rpn_cls_loss.cpu().data.numpy()[0],
net.rpn_reg_loss.cpu().data.numpy()[0],
net.rcnn_cls_loss.cpu().data.numpy()[0],
net.rcnn_reg_loss.cpu().data.numpy()[0],
net.mask_cls_loss.cpu().data.numpy()[0],
))
sum_train_loss += batch_loss
sum_train_acc += batch_acc
sum += 1
if i % iter_smooth == 0:
train_loss = sum_train_loss / sum
train_acc = sum_train_acc / sum
sum_train_loss = np.zeros(6, np.float32)
sum_train_acc = 0.
sum = 0
print(
'\r%0.4f %5.1f k %6.2f %4.1f m | %0.3f %0.2f %0.2f %0.2f %0.2f %0.2f | %0.3f %0.2f %0.2f %0.2f %0.2f %0.2f | %0.3f %0.2f %0.2f %0.2f %0.2f %0.2f | %s %d,%d,%s' % ( \
rate, i / 1000, epoch, num_products / 1000000,
valid_loss[0], valid_loss[1], valid_loss[2], valid_loss[3], valid_loss[4], valid_loss[5],
# valid_acc,
train_loss[0], train_loss[1], train_loss[2], train_loss[3], train_loss[4], train_loss[5],
# train_acc,
batch_loss[0], batch_loss[1], batch_loss[2], batch_loss[3], batch_loss[4], batch_loss[5],
# batch_acc,
time_to_str((time.time() - start) / 60), i, j, str(inputs.size())), end='', flush=True)
j = j + 1
pass # -- end of one data loader --
pass # -- end of all iterations --
if 1: # save last
torch.save(net.state_dict(),
out_dir + '/checkpoint/%d_model.pth' % (i))
torch.save(
{
'optimizer': optimizer.state_dict(),
'iter': i,
'epoch': epoch,
}, out_dir + '/checkpoint/%d_optimizer.pth' % (i))
log.write('\n')
def run_check_compute_precision_for_box():
H, W = 256, 256
truth_label = np.array([1, 1, 2, 1, -1], np.float32)
truth_box = np.array([
[
10,
10,
0,
0,
],
[
100,
10,
0,
0,
],
[
50,
50,
0,
0,
],
[
10,
100,
0,
0,
],
[
100,
100,
0,
0,
],
], np.float32)
truth_box[:, 2] = truth_box[:, 0] + 25
truth_box[:, 3] = truth_box[:, 1] + 25
box = np.zeros((7, 4), np.float32)
box[:5] = truth_box[[0, 1, 2, 4, 3]] + np.random.uniform(-10, 10, size=(5, 4))
box[5] = [
10,
10,
80,
80,
]
box[6] = [
100,
100,
180,
180,
]
thresholds = [0.3, 0.5, 0.6]
precisions, recalls, results, truth_results = \
compute_precision_for_box(box, truth_box, truth_label, thresholds)
for precision, recall, result, truth_result, threshold in zip(precisions, recalls, results,
truth_results, thresholds):
print('')
print('threshold ', threshold)
print('precision ', precision)
print('recall ', recall)
image = np.zeros((H, W, 3), np.uint8)
for i, b in enumerate(truth_box):
x0, y0, x1, y1 = b.astype(np.int32)
if truth_result[i] == HIT:
draw_screen_rect(image, (x0, y0), (x1, y1), (0, 255, 255), 0.5)
if truth_result[i] == MISS:
draw_screen_rect(image, (x0, y0), (x1, y1), (0, 0, 255), 0.5)
if truth_result[i] == INVALID:
draw_screen_rect(image, (x0, y0), (x1, y1), (255, 255, 255), 0.5)
for i, b in enumerate(box):
x0, y0, x1, y1 = b.astype(np.int32)
if result[i] == TP:
cv2.rectangle(image, (x0, y0), (x1, y1), (0, 255, 255), 1)
if result[i] == FP:
cv2.rectangle(image, (x0, y0), (x1, y1), (0, 0, 255), 1)
if result[i] == INVALID:
draw_dotted_rect(image, (x0, y0), (x1, y1), (255, 255, 255), 1)
image_show("image_box", image, 1)
cv2.waitKey(0)
def make_one_rpn_target(cfg, mode, input, window, truth_box, truth_label):
num_window = len(window)
label = np.zeros((num_window, ), np.float32)
label_assign = np.zeros((num_window, ), np.int32)
label_weight = np.ones((num_window, ), np.float32)
target = np.zeros((num_window, 4), np.float32)
target_weight = np.zeros((num_window, ), np.float32)
num_truth_box = len(truth_box)
if num_truth_box != 0:
_, height, width = input.size()
# "SSD: Single Shot MultiBox Detector" - Wei Liu, Dragomir Anguelov, Dumitru Erhan, Christian Szegedy
# -- see Table.3
#
# allowed_border=0
# invalid_index = (
# (window[:,0] < allowed_border) | \
# (window[:,1] < allowed_border) | \
# (window[:,2] > width-1 - allowed_border) | \
# (window[:,3] > height-1 - allowed_border))
# label_weight [invalid_index]=0
# target_weight[invalid_index]=0
# classification ---------------------------------------
# bg
overlap = cython_box_overlap(window, truth_box)
argmax_overlap = np.argmax(overlap, 1)
max_overlap = overlap[np.arange(num_window), argmax_overlap]
bg_index = max_overlap < cfg.rpn_train_bg_thresh_high
label[bg_index] = 0
label_weight[bg_index] = 1
# fg
fg_index = max_overlap >= cfg.rpn_train_fg_thresh_low
label[
fg_index] = 1 #<todo> extend to multi-class ... need to modify regression below too
label_weight[fg_index] = 1
label_assign[...] = argmax_overlap
# fg: for each truth, window with highest overlap, include multiple maxs
argmax_overlap = np.argmax(overlap, 0)
max_overlap = overlap[argmax_overlap, np.arange(num_truth_box)]
argmax_overlap, a = np.where(overlap == max_overlap)
fg_index = argmax_overlap
label[fg_index] = 1
label_weight[fg_index] = 1
label_assign[fg_index] = a
# regression ---------------------------------------
fg_index = np.where(label != 0)
target_window = window[fg_index]
target_truth_box = truth_box[label_assign[fg_index]]
target[fg_index] = rpn_encode(target_window, target_truth_box)
target_weight[fg_index] = 1
#don't care------------
invalid_truth_label = np.where(truth_label < 0)[0]
invalid_index = np.isin(label_assign,
invalid_truth_label) & (label != 0)
label_weight[invalid_index] = 0
target_weight[invalid_index] = 0
#class balancing
if 1:
fg_index = np.where((label_weight != 0) & (label != 0))[0]
bg_index = np.where((label_weight != 0) & (label == 0))[0]
num_fg = len(fg_index)
num_bg = len(bg_index)
label_weight[fg_index] = 1
label_weight[bg_index] = num_fg / num_bg
#scale balancing
num_scales = len(cfg.rpn_scales)
num_bases = [len(b) for b in cfg.rpn_base_apsect_ratios]
start = 0
for l in range(num_scales):
h, w = int(height // 2**l), int(width // 2**l)
end = start + h * w * num_bases[l]
## label_weight[start:end] *= (2**l)**2
start = end
#task balancing
target_weight[fg_index] = label_weight[fg_index]
if 0: #<debug> ---------------------------------------
image = input.data.cpu().numpy() * 255
image = image.transpose((1, 2, 0)).astype(np.uint8).copy()
all1 = draw_rpn_target_truth_box(image, truth_box, truth_label)
all2 = draw_rpn_target_label(cfg, image, window, label,
label_assign, label_weight)
all3 = draw_rpn_target_target(cfg, image, window, target,
target_weight)
all4 = draw_rpn_target_target1(cfg, image, window, target,
target_weight)
image_show('all1', all1, 1)
image_show('all2', all2, 1)
image_show('all3', all3, 1)
image_show('all4', all4, 1)
cv2.waitKey(0)
# save
label = Variable(torch.from_numpy(label)).cuda()
label_assign = Variable(torch.from_numpy(label_assign)).cuda()
label_weight = Variable(torch.from_numpy(label_weight)).cuda()
target = Variable(torch.from_numpy(target)).cuda()
target_weight = Variable(torch.from_numpy(target_weight)).cuda()
return label, label_assign, label_weight, target, target_weight
def run_make_annotation():
split = 'train1_ids_all_670'
ids = read_list_from_file(DATA_DIR + '/split/' + split, comment='#')
num_ids = len(ids)
for i in range(num_ids):
id = ids[i]
# image_files = glob.glob(DATA_DIR + '/image/' + id + '/images/*.png')
image_files = list(
(DATA_DIR / ('image' + id) / 'images').glob('*.png'))
assert (len(image_files) == 1)
image_file = image_files[0]
print(id)
# ----clear old -----------------------------
if 1:
for f in [
'one_mask.png',
'one_countour_mask.png',
'one_countour_image.png',
'one_countour.png',
'overlap.png',
'one_center.png',
'/masks.npy',
'/labels.npy',
'/countour_on_image.png',
'/cut_mask.png',
'/label.npy',
'/mask.png',
'/overlay.png',
'/multi.npy',
'/multi.png',
'/instance.npy',
'/instance.png',
'/multi_instance.npy',
'/multi_instance.png',
]:
file = DATA_DIR + '/image/' + id + '/' + f
if os.path.exists(file):
os.remove(file)
# ----clear old -----------------------------
# image
image = cv2.imread(image_file, cv2.IMREAD_COLOR)
H, W, C = image.shape
multi_mask = np.zeros((H, W), np.int32)
mask = np.zeros((H, W), np.uint8)
countour = np.zeros((H, W), np.uint8)
# mask_files = glob.glob(DATA_DIR + '/image/' + id + '/masks/*.png')
mask_files = list((DATA_DIR / ('image' + id) / 'masks').glob('*.png'))
mask_files.sort()
count = len(mask_files)
for i in range(count):
mask_file = mask_files[i]
thresh = cv2.imread(mask_file, cv2.IMREAD_GRAYSCALE)
thresh = thresh > 128
index = np.where(thresh == True)
multi_mask[thresh] = i + 1
mask = np.logical_or(mask, thresh)
countour = np.logical_or(countour, thresh_to_inner_contour(thresh))
## save and show -------------------------------------------
countour_on_image = image.copy()
countour_on_image = countour[:, :, np.newaxis] * np.array(
(0, 255, 0)) + (1 - countour[:, :, np.newaxis]) * countour_on_image
countour_overlay = countour * 255
mask_overlay = mask * 255
multi_mask_overlay = multi_mask_to_overlay(multi_mask)
image_show('image', image)
image_show('mask', mask_overlay)
image_show('multi_mask', multi_mask_overlay)
image_show('countour', countour_overlay)
image_show('countour_on_image', countour_on_image)
np.save(DATA_DIR + '/image/' + id + '/multi_mask.npy', multi_mask)
cv2.imwrite(DATA_DIR + '/image/' + id + '/multi_mask.png',
multi_mask_overlay)
cv2.imwrite(DATA_DIR + '/image/' + id + '/mask.png', mask_overlay)
cv2.imwrite(DATA_DIR + '/image/' + id + '/countour.png',
countour_overlay)
cv2.imwrite(DATA_DIR + '/image/' + id + '/countour_on_image.png',
countour_on_image)
cv2.waitKey(1)