def predict(imagePath, trimapPath, outputPath):
image = cv.imread(imagePath)
trimap_img = cv.imread(trimapPath)[...,0]
x_test = np.empty((1, img_rows, img_cols, 4), dtype=np.float32)
x_test[0, :, :, 0:3] = image / 255.
x_test[0, :, :, 3] = trimap_img / 255.
y_pred = final.predict(x_test)
y_pred = np.reshape(y_pred, (img_rows, img_cols))
y_pred = y_pred * 255.0
y_pred = get_final_output(y_pred, trimap_img)
y_pred = y_pred.astype(np.uint8)
cv.imwrite(outputPath, y_pred)
K.clear_session()
x_test = np.empty((1, img_rows, img_cols, 4), dtype=np.float32)
x_test[0, :, :, 0:3] = bgr_img / 255.
x_test[0, :, :, 3] = trimap / 255.
y_true = np.empty((1, img_rows, img_cols, 2), dtype=np.float32)
y_true[0, :, :, 0] = alpha / 255.
y_true[0, :, :, 1] = trimap / 255.
y_pred = final.predict(x_test)
# print('y_pred.shape: ' + str(y_pred.shape))
y_pred = np.reshape(y_pred, (img_rows, img_cols))
print(y_pred.shape)
y_pred = y_pred * 255.0
y_pred = get_final_output(y_pred, trimap)
y_pred = y_pred.astype(np.uint8)
sad_loss = compute_sad_loss(y_pred, alpha, trimap)
mse_loss = compute_mse_loss(y_pred, alpha, trimap)
str_msg = 'sad_loss: %.4f, mse_loss: %.4f, crop_size: %s' % (sad_loss, mse_loss, str(crop_size))
print(str_msg)
out = y_pred.copy()
draw_str(out, (10, 20), str_msg)
cv.imwrite('images/{}_out.png'.format(i), out)
sample_bg = sample_bgs[i]
bg = cv.imread(os.path.join(bg_test, sample_bg))
bh, bw = bg.shape[:2]
wratio = img_cols / bw
# create patches
x = np.dstack((img, np.expand_dims(trimap, axis=2))) / 255.
patches = create_patches(x, PATCH_SIZE)
# create mat for patches predictions
patches_count = np.product(
patch_dims(mat_size=trimap.shape, patch_size=PATCH_SIZE)
)
patches_predictions = np.zeros(shape=(patches_count, PATCH_SIZE, PATCH_SIZE))
# predicting
for i in range(patches.shape[0]):
print("Predicting patches {}/{}".format(i + 1, patches_count))
patch_prediction = final.predict(np.expand_dims(patches[i, :, :, :], axis=0))
patches_predictions[i] = np.reshape(patch_prediction, (PATCH_SIZE, PATCH_SIZE)) * 255.
# assemble
result = assemble_patches(patches_predictions, trimap.shape, PATCH_SIZE)
result = result[:img_size[0], :img_size[1]]
prediction = get_final_output(result, trimap).astype(np.uint8)
# save into files
cv.imshow("result", prediction)
cv.imshow("image", img)
cv.waitKey(0)
K.clear_session()
def test_alphacom(config, resume):
config['data_loader']['args']['batch_size'] = 1
test_data_loader = alpha_com_dataloader(config)
batch_size = config['data_loader']['args']['batch_size']
# build model architecture
model = get_instance(module_arch, 'arch', config)
model.summary()
# get function handles of loss and metrics
# loss_fn = getattr(module_loss, config['loss'])
metric_fns = [getattr(module_metric, met) for met in config['metrics']]
# load state dict
checkpoint = torch.load(resume)
state_dict = checkpoint['state_dict']
if config['n_gpu'] > 1:
model = torch.nn.DataParallel(model)
model.load_state_dict(state_dict)
# prepare model for testing
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = model.to(device)
model.eval() # 一般有drop 或者 bn用这个
with torch.no_grad():
# for i, data in enumerate(tqdm(test_data_loader)):
for i, data in enumerate(test_data_loader):
image = data[0][0].permute(1, 2, 0)
h, w, c = image.size()
new_h = h - h % 32
new_w = w - w % 32
# print(image.size(), h, w)
image = image.numpy()
# print(image.shape, new_h, new_w)
image = cv2.resize(image, (new_w, new_h),
interpolation=cv2.INTER_LINEAR)
# print(image.shape)
image = torch.from_numpy(image).permute(
2, 0, 1)[np.newaxis, :, :, :].to(device)
trimap1 = data[1][0].permute(1, 2, 0)
trimap2 = data[2][0].permute(1, 2, 0)
trimap3 = data[3][0].permute(1, 2, 0)
image_name = data[4][0]
# print(trimap1.size())
trimap1 = trimap1.numpy()
# print(trimap1.shape)
# for i in trimap1: print(i)
# cv2.imshow("213414",trimap1)
# cv2.waitKey(0)
trimap1 = cv2.resize(trimap1, (new_w, new_h),
interpolation=cv2.INTER_LINEAR)
trimap1 = torch.from_numpy(trimap1)[np.newaxis,
np.newaxis, :, :].to(device)
trimap2 = trimap2.numpy()
trimap2 = cv2.resize(trimap2, (new_w, new_h),
interpolation=cv2.INTER_LINEAR)
trimap2 = torch.from_numpy(trimap2)[np.newaxis,
np.newaxis, :, :].to(device)
trimap3 = trimap3.numpy()
trimap3 = cv2.resize(trimap3, (new_w, new_h),
interpolation=cv2.INTER_LINEAR)
trimap3 = torch.from_numpy(trimap3)[np.newaxis,
np.newaxis, :, :].to(device)
# print(image.size(), trimap1.size(), trimap2.size(), trimap3.size())
if config['arch']['args']['stage'] == 0:
pred1 = model(torch.cat((image, trimap1), dim=1))
pred2 = model(torch.cat((image, trimap2), dim=1))
pred3 = model(torch.cat((image, trimap3), dim=1))
else:
_, pred1 = model(torch.cat((image, trimap1), dim=1))
_, pred2 = model(torch.cat((image, trimap2), dim=1))
_, pred3 = model(torch.cat((image, trimap3), dim=1))
pred1 *= 255
pred2 *= 255
pred3 *= 255
pred1 = pred1[0].permute(1, 2, 0).cpu().numpy()
image1 = get_final_output(pred1, trimap1)
image1 = cv2.resize(image1, (w, h), interpolation=cv2.INTER_LINEAR)
pred2 = pred2[0].permute(1, 2, 0).cpu().numpy()
image2 = get_final_output(pred1, trimap2)
image2 = cv2.resize(image2, (w, h), interpolation=cv2.INTER_LINEAR)
pred3 = pred3[0].permute(1, 2, 0).cpu().numpy()
image3 = get_final_output(pred1, trimap3)
image3 = cv2.resize(image3, (w, h), interpolation=cv2.INTER_LINEAR)
# print(image.size())
# print(pred1.shape,pred2.shape,pred3.shape)
# pred3 = cv2.resize(pred3, (w, h), interpolation=cv2.INTER_LINEAR)
cv2.imwrite("alpha_com_output/Trimap1/{}".format(image_name),
image1)
cv2.imwrite("alpha_com_output/Trimap2/{}".format(image_name),
image2)
cv2.imwrite("alpha_com_output/Trimap3/{}".format(image_name),
image3)
print(i)
cv.imwrite('images/{}_trimap.png'.format(i), np.array(trimap).astype(np.uint8))
cv.imwrite('images/{}_alpha.png'.format(i), np.array(alpha).astype(np.uint8))
x_test = np.empty((1, 320, 320, 4), dtype=np.float32)
x_test[0, :, :, 0:3] = bgr_img / 255.
x_test[0, :, :, 3] = trimap / 255.
y_true = np.empty((1, 320, 320, 2), dtype=np.float32)
y_true[0, :, :, 0] = alpha / 255.
y_true[0, :, :, 1] = trimap / 255.
y_pred = final.predict(x_test)
# print('y_pred.shape: ' + str(y_pred.shape))
y_pred = np.reshape(y_pred, (img_rows, img_cols))
print(y_pred.shape)
y_pred = y_pred * 255.0
y_pred = get_final_output(y_pred, trimap)
y_pred = y_pred.astype(np.uint8)
sad_loss = compute_sad_loss(y_pred, alpha, trimap)
mse_loss = compute_mse_loss(y_pred, alpha, trimap)
str_msg = 'sad_loss: %.4f, mse_loss: %.4f, crop_size: %s' % (sad_loss, mse_loss, str(crop_size))
print(str_msg)
out = y_pred
draw_str(out, (10, 20), str_msg)
cv.imwrite('images/{}_out.png'.format(i), out)
K.clear_session()
ap.add_argument("-i", "--image", help="path to the image file")
ap.add_argument("-t", "--trimap", help="path to the trimap file")
args = vars(ap.parse_args())
image_path = args["image"]
trimap_path = args["trimap"]
if image_path is None:
image_path = 'images/image.jpg'
if trimap_path is None:
trimap_path = 'images/trimap.jpg'
print('Start processing image: {}'.format(image_path))
x_test = np.empty((1, img_rows, img_cols, 4), dtype=np.float32)
bgr_img = cv.imread(image_path)
trimap = cv.imread(trimap_path, 0)
x_test[0, :, :, 0:3] = bgr_img / 255.
x_test[0, :, :, 3] = trimap / 255.
out = final.predict(x_test)
out = np.reshape(out, (img_rows, img_cols))
print(out.shape)
out = out * 255.0
out = get_final_output(out, trimap)
out = out.astype(np.uint8)
cv.imshow('out', out)
cv.imwrite('images/out.png', out)
cv.waitKey(0)
cv.destroyAllWindows()
def video_test(videopath, models_path, videomask_path, is_rotate=False):
cam = cv.VideoCapture(videopath)
width = int(cam.get(cv.CAP_PROP_FRAME_WIDTH))
height = int(cam.get(cv.CAP_PROP_FRAME_HEIGHT))
cam_mask = cv.VideoCapture(videomask_path)
width_mask = int(cam_mask.get(cv.CAP_PROP_FRAME_WIDTH))
height_mask = int(cam_mask.get(cv.CAP_PROP_FRAME_HEIGHT))
pretrained_path = models_path #'models/final.87-0.0372.hdf5' #'models/final.42-0.0398.hdf5'
encoder_decoder = build_encoder_decoder()
final = build_refinement(encoder_decoder)
final.load_weights(pretrained_path)
print(final.summary())
tri_videopath = videopath[:-4] + '_tri.mp4'
tri_video = video_save(tri_videopath, w=width_mask, h=height_mask)
matting_videopath = videopath[:-4] + '_out.mp4'
matting_video = video_save(matting_videopath, w=width_mask, h=height_mask)
comp_videopath = videopath[:-4] + '_comp.mp4'
comp_video = video_save(comp_videopath, w=width_mask, h=height_mask)
while (cam.isOpened() and cam_mask.isOpened()):
start_time = time.time()
ret, frame = cam.read()
ret, frame_mask = cam_mask.read()
if is_rotate:
frame = imutils.rotate_bound(frame, 90)
frame_mask = imutils.rotate_bound(frame_mask, 90)
# print(frame.shape)
if frame is None:
print('Error image!')
break
if frame_mask is None:
print('Error mask image!')
break
bg_h, bg_w = height, width
print('bg_h, bg_w: ' + str((bg_h, bg_w)))
# a = get_alpha_test(image_name)
a = cv.cvtColor(frame_mask, cv.COLOR_BGR2GRAY)
_, a = cv.threshold(a, 240, 255, cv.THRESH_BINARY)
a_h, a_w = height_mask, width_mask
print('a_h, a_w: ' + str((a_h, a_w)))
alpha = np.zeros((bg_h, bg_w), np.float32)
alpha[0:a_h, 0:a_w] = a
trimap = generate_trimap_withmask(alpha)
# fg = np.array(np.greater_equal(a, 255).astype(np.float32))
# cv.imshow('test_show',fg)
different_sizes = [(320, 320), (320, 320), (320, 320), (480, 480),
(640, 640)]
crop_size = random.choice(different_sizes)
bgr_img = frame
alpha = alpha
trimap = trimap
# cv.imwrite('images/{}_image.png'.format(i), np.array(bgr_img).astype(np.uint8))
# cv.imwrite('images/{}_trimap.png'.format(i), np.array(trimap).astype(np.uint8))
# cv.imwrite('images/{}_alpha.png'.format(i), np.array(alpha).astype(np.uint8))
# x_test = np.empty((1, img_rows, img_cols, 4), dtype=np.float32)
# x_test[0, :, :, 0:3] = bgr_img / 255.
# x_test[0, :, :, 3] = trimap / 255.
x_test = np.empty((1, 320, 320, 4), dtype=np.float32)
bgr_img1 = cv.resize(bgr_img, (320, 320))
trimap1 = cv.resize(trimap, (320, 320))
x_test[0, :, :, 0:3] = bgr_img1 / 255.
x_test[0, :, :, 3] = trimap1 / 255.
y_true = np.empty((1, img_rows, img_cols, 2), dtype=np.float32)
y_true[0, :, :, 0] = alpha / 255.
y_true[0, :, :, 1] = trimap / 255.
y_pred = final.predict(x_test)
# print('y_pred.shape: ' + str(y_pred.shape))
# y_pred = np.reshape(y_pred, (img_rows, img_cols))
y_pred = np.reshape(y_pred, (320, 320))
print(y_pred.shape)
y_pred = cv.resize(y_pred, (width, height))
y_pred = y_pred * 255.0
cv.imshow('pred', y_pred)
y_pred = get_final_output(y_pred, trimap)
y_pred = y_pred.astype(np.uint8)
sad_loss = compute_sad_loss(y_pred, alpha, trimap)
mse_loss = compute_mse_loss(y_pred, alpha, trimap)
str_msg = 'sad_loss: %.4f, mse_loss: %.4f, crop_size: %s' % (
sad_loss, mse_loss, str(crop_size))
print(str_msg)
out = y_pred.copy()
comp = composite_alpha(frame, out)
draw_str(out, (10, 20), str_msg)
trimap_show = np.stack((trimap, trimap, trimap), -1)
out_show = cv.merge((out, out, out))
# print(trimap_show.shape,out_show.shape,comp.shape)
tri_video.write(trimap_show)
matting_video.write(out_show)
comp_video.write(comp)
# cv.imwrite('images/{}_out.png'.format(filename[6:]), out)
#### composite background
# sample_bg = sample_bgs[i]
# bg = cv.imread(os.path.join(bg_test, sample_bg))
# bh, bw = bg.shape[:2]
# wratio = img_cols / bw
# hratio = img_rows / bh
# ratio = wratio if wratio > hratio else hratio
# if ratio > 1:
# bg = cv.resize(src=bg, dsize=(math.ceil(bw * ratio), math.ceil(bh * ratio)), interpolation=cv.INTER_CUBIC)
# # im, bg = composite4(bgr_img, bg, y_pred, img_cols, img_rows)
# im, bg = composite4(bgr_img, bg, y_pred, img_cols, img_rows)
# # cv.imwrite('images/{}_compose.png'.format(filename[6:]), im)
# # cv.imwrite('images/{}_new_bg.png'.format(i), bg)
print("Time: {:.2f} s / img".format(time.time() - start_time))
cv.imshow('out', out)
cv.imshow('frame', frame)
cv.imshow('comp', comp)
cv.imshow('trimap', trimap)
if cv.waitKey(1) & 0xFF == ord('q'):
break
cam.release()
cam_mask.release()
tri_video.release()
matting_video.release()
comp_video.release()
cv.destroyAllWindows()