def predict(self, img):
rgb_origin = img
img_numpy = img
img = torch.from_numpy(img.copy()).float()
img = img.cuda()
img_h, img_w = img.shape[0], img.shape[1]
img_trans = FastBaseTransform()(img.unsqueeze(0))
net_outs = self.net(img_trans)
nms_outs = NMS(net_outs, 0)
results = after_nms(nms_outs,
img_h,
img_w,
crop_masks=not self.args.no_crop,
visual_thre=self.args.visual_thre)
torch.cuda.synchronize()
temp = self.time_here
self.time_here = time.time()
self.frame_times.add(self.time_here - temp)
fps = 1 / self.frame_times.get_avg()
frame_numpy = draw_img(results,
img,
self.args,
class_color=True,
fps=fps)
return frame_numpy
timer.start()
img_h, img_w = img_origin.shape[0:2]
with timer.counter('forward'):
class_p, box_p, coef_p, proto_p, anchors = sess.run(None, {input_name: img})
with timer.counter('nms'):
ids_p, class_p, box_p, coef_p, proto_p = nms_numpy(class_p, box_p, coef_p, proto_p, anchors, cfg)
with timer.counter('after_nms'):
ids_p, class_p, boxes_p, masks_p = after_nms_numpy(ids_p, class_p, box_p, coef_p,
proto_p, img_h, img_w, cfg)
with timer.counter('save_img'):
img_numpy = draw_img(ids_p, class_p, boxes_p, masks_p, img_origin, cfg, img_name=img_name)
cv2.imwrite(f'results/images/{img_name}', img_numpy)
aa = time.perf_counter()
if i > 0:
batch_time = aa - temp
timer.add_batch_time(batch_time)
temp = aa
if i > 0:
t_t, t_d, t_f, t_nms, t_an, t_si = timer.get_times(['batch', 'data', 'forward',
'nms', 'after_nms', 'save_img'])
fps, t_fps = 1 / (t_d + t_f + t_nms + t_an), 1 / t_t
bar_str = progress_bar.get_bar(i + 1)
print(f'\rTesting: {bar_str} {i + 1}/{ds}, fps: {fps:.2f} | total fps: {t_fps:.2f} | '
f't_t: {t_t:.3f} | t_d: {t_d:.3f} | t_f: {t_f:.3f} | t_nms: {t_nms:.3f} | '
net_outs = net(img_trans)
nms_outs = NMS(net_outs, args.traditional_nms)
show_lincomb = bool(args.show_lincomb and args.image_path)
with timer.env('after nms'):
results = after_nms(nms_outs,
img_h,
img_w,
show_lincomb=show_lincomb,
crop_masks=not args.no_crop,
visual_thre=args.visual_thre,
img_name=img_name)
torch.cuda.synchronize()
img_numpy = draw_img(results, img_origin, args)
cv2.imwrite(f'results/images/{img_name}', img_numpy)
print(f'\r{i + 1}/{num}', end='')
print('\nDone.')
# detect videos
elif args.video is not None:
vid = cv2.VideoCapture('videos/' + args.video)
target_fps = round(vid.get(cv2.CAP_PROP_FPS))
frame_width = round(vid.get(cv2.CAP_PROP_FRAME_WIDTH))
frame_height = round(vid.get(cv2.CAP_PROP_FRAME_HEIGHT))
num_frames = round(vid.get(cv2.CAP_PROP_FRAME_COUNT))
def process():
try:
destFile = ""
if request.method == 'POST':
file = request.files['file']
if file and allowed_file(file.filename):
filename = secure_filename(file.filename)
destFile = os.path.join(app.config['UPLOAD_FOLDER'], filename)
file.save(destFile)
app.logger.warning('filename=(%s)', filename)
else:
app.logger.warning("Request dictionary data: {}".format(request.data))
app.logger.warning("Request dictionary form: {}".format(request.form))
url = request.form["url"]
print("url:", url)
# download file
destFile = download_file(url)
# app.logger.error('An error occurred')
app.logger.warning('destFile=(%s)', destFile)
img_name = destFile.split('/')[-1]
app.logger.warning('img_name=(%s)', img_name)
# img_origin = cv2.imread(one_img)
# img_tensor = torch.from_numpy(img_origin).float()
img_origin = cv2.imread(destFile)
# torch.from_numpy(img_origin).float()
img_tensor = torch.from_numpy(img_origin).float()
if cuda:
# img_origin = img_origin.cuda()
img_tensor = img_tensor.cuda()
img_h, img_w = img_tensor.shape[0], img_tensor.shape[1]
img_trans = FastBaseTransform()(img_tensor.unsqueeze(0))
net_outs = net(img_trans)
nms_outs = NMS(net_outs, args.traditional_nms)
show_lincomb = bool(args.show_lincomb)
results = after_nms(nms_outs, img_h, img_w, show_lincomb=show_lincomb, crop_masks=not args.no_crop,
visual_thre=args.visual_thre, img_name=img_name)
# img_h, img_w = img_origin.shape[0], img_origin.shape[1]
# img_trans = FastBaseTransform()(img_origin.unsqueeze(0))
# net_outs = net(img_trans)
# nms_outs = NMS(net_outs, args.traditional_nms)
app.logger.warning('img_h=(%s)', img_h)
app.logger.warning('img_w=(%s)', img_w)
app.logger.warning('cuda=(%s)', cuda)
app.logger.warning('args.show_lincomb=(%s)', args.show_lincomb)
app.logger.warning('args.no_crop=(%s)', args.no_crop)
app.logger.warning('args.visual_thre=(%s)', args.visual_thre)
app.logger.warning('args=(%s)', args)
# show_lincomb = bool(args.show_lincomb)
with timer.env('after nms'):
results = after_nms(nms_outs, img_h, img_w, show_lincomb=show_lincomb, crop_masks=not args.no_crop,
visual_thre=args.visual_thre, img_name=img_name)
if cuda:
torch.cuda.synchronize()
# app.logger.warning('results=(%s)', results)
# img_numpy = draw_img(results, img_origin, args)
img_numpy = draw_img(results, img_origin, img_name, args)
cv2.imwrite(f'results/images/{img_name}', img_numpy)
# print(f'\r{i + 1}/{num}', end='')
try:
im = Image.open(f'results/images/{img_name}')
# im = Image.open(destFile)
io = BytesIO()
im.save(io, format='JPEG')
return Response(io.getvalue(), mimetype='image/jpeg')
except IOError:
abort(404)
# return send_from_directory('.', filename), 200
callback = json.dumps({"results": results})
return callback, 200
except:
traceback.print_exc()
return {'message': 'input error'}, 400
with timer.counter('forward'):
net_outs = net(img)
with timer.counter('nms'):
nms_outs = nms(cfg, net_outs)
with timer.counter('after_nms'):
results = after_nms(nms_outs,
img_h,
img_w,
cfg,
img_name=img_name)
with timer.counter('save_img'):
img_numpy = draw_img(results,
img_origin,
cfg,
img_name=img_name)
cv2.imwrite(f'results/images/{img_name}', img_numpy)
aa = time.perf_counter()
if i > 0:
batch_time = aa - temp
timer.add_batch_time(batch_time)
temp = aa
if i > 0:
t_t, t_d, t_f, t_nms, t_an, t_si = timer.get_times([
'batch', 'data', 'forward', 'nms', 'after_nms', 'save_img'
])
fps, t_fps = 1 / (t_d + t_f + t_nms + t_an), 1 / t_t
bar_str = progress_bar.get_bar(i + 1)
img_name = one_img.split('/')[-1]
img_origin = cv2.imread(one_img)
img_tensor = torch.from_numpy(img_origin).float()
if cuda:
img_tensor = img_tensor.cuda()
img_h, img_w = img_tensor.shape[0], img_tensor.shape[1]
img_trans = FastBaseTransform()(img_tensor.unsqueeze(0))
tensor_outs=tf_rep.run(img_trans.cpu().numpy())._0
net_outs = net(img_trans)
nms_outs = NMS(net_outs, args.traditional_nms)
show_lincomb = bool(args.show_lincomb and args.image_path)
results = after_nms(nms_outs, img_h, img_w, show_lincomb=show_lincomb, crop_masks=not args.no_crop,
visual_thre=args.visual_thre, img_name=img_name)
img_numpy = draw_img(results, img_origin, img_name, args)
cv2.imwrite(f'results/images/{img_name}', img_numpy)
print(f'\r{i + 1}/{len(images)}', end='')
print('\nDone.')
# detect videos
elif args.video is not None:
vid = cv2.VideoCapture('videos/' + args.video)
target_fps = round(vid.get(cv2.CAP_PROP_FPS))
frame_width = round(vid.get(cv2.CAP_PROP_FRAME_WIDTH))
frame_height = round(vid.get(cv2.CAP_PROP_FRAME_HEIGHT))
num_frames = round(vid.get(cv2.CAP_PROP_FRAME_COUNT))
name = args.video.split('/')[-1]
def main():
parser = argparse.ArgumentParser(description='YOLACT Detection.')
parser.add_argument('--weight', default='weights/best_30.5_res101_coco_392000.pth', type=str)
parser.add_argument('--image', default=None, type=str, help='The folder of images for detecting.')
parser.add_argument('--video', default=None, type=str, help='The path of the video to evaluate.')
parser.add_argument('--img_size', type=int, default=544, help='The image size for validation.')
parser.add_argument('--traditional_nms', default=False, action='store_true', help='Whether to use traditional nms.')
parser.add_argument('--hide_mask', default=False, action='store_true', help='Hide masks in results.')
parser.add_argument('--hide_bbox', default=False, action='store_true', help='Hide boxes in results.')
parser.add_argument('--hide_score', default=False, action='store_true', help='Hide scores in results.')
parser.add_argument('--cutout', default=False, action='store_true', help='Cut out each object and save.')
parser.add_argument('--save_lincomb', default=False, action='store_true', help='Show the generating process of masks.')
parser.add_argument('--no_crop', default=False, action='store_true',
help='Do not crop the output masks with the predicted bounding box.')
parser.add_argument('--real_time', default=False, action='store_true', help='Show the detection results real-timely.')
parser.add_argument('--visual_thre', default=0.3, type=float,
help='Detections with a score under this threshold will be removed.')
args = parser.parse_args()
prefix = re.findall(r'best_\d+\.\d+_', args.weight)[0]
suffix = re.findall(r'_\d+\.pth', args.weight)[0]
args.cfg = args.weight.split(prefix)[-1].split(suffix)[0]
cfg = get_config(args, mode='detect')
net = Yolact(cfg)
net.load_weights(cfg.weight, cfg.cuda)
net.eval()
if cfg.cuda:
cudnn.benchmark = True
cudnn.fastest = True
net = net.cuda()
# detect images
if cfg.image is not None:
dataset = COCODetection(cfg, mode='detect')
data_loader = data.DataLoader(dataset, 1, num_workers=2, shuffle=False, pin_memory=True, collate_fn=detect_collate)
ds = len(data_loader)
assert ds > 0, 'No .jpg images found.'
progress_bar = ProgressBar(40, ds)
timer.reset()
for i, (img, img_origin, img_name) in enumerate(data_loader):
if i == 1:
timer.start()
if cfg.cuda:
img = img.cuda()
img_h, img_w = img_origin.shape[0:2]
with torch.no_grad(), timer.counter('forward'):
class_p, box_p, coef_p, proto_p = net(img)
with timer.counter('nms'):
ids_p, class_p, box_p, coef_p, proto_p = nms(class_p, box_p, coef_p, proto_p, net.anchors, cfg)
with timer.counter('after_nms'):
ids_p, class_p, boxes_p, masks_p = after_nms(ids_p, class_p, box_p, coef_p, proto_p,
img_h, img_w, cfg, img_name=img_name)
with timer.counter('save_img'):
img_numpy = draw_img(ids_p, class_p, boxes_p, masks_p, img_origin, cfg, img_name=img_name)
cv2.imwrite(f'results/images/{img_name}', img_numpy)
aa = time.perf_counter()
if i > 0:
batch_time = aa - temp
timer.add_batch_time(batch_time)
temp = aa
if i > 0:
t_t, t_d, t_f, t_nms, t_an, t_si = timer.get_times(['batch', 'data', 'forward',
'nms', 'after_nms', 'save_img'])
fps, t_fps = 1 / (t_d + t_f + t_nms + t_an), 1 / t_t
bar_str = progress_bar.get_bar(i + 1)
print(f'\rTesting: {bar_str} {i + 1}/{ds}, fps: {fps:.2f} | total fps: {t_fps:.2f} | '
f't_t: {t_t:.3f} | t_d: {t_d:.3f} | t_f: {t_f:.3f} | t_nms: {t_nms:.3f} | '
f't_after_nms: {t_an:.3f} | t_save_img: {t_si:.3f}', end='')
print('\nFinished, saved in: results/images.')
# detect videos
elif cfg.video is not None:
vid = cv2.VideoCapture(cfg.video)
target_fps = round(vid.get(cv2.CAP_PROP_FPS))
frame_width = round(vid.get(cv2.CAP_PROP_FRAME_WIDTH))
frame_height = round(vid.get(cv2.CAP_PROP_FRAME_HEIGHT))
num_frames = round(vid.get(cv2.CAP_PROP_FRAME_COUNT))
name = cfg.video.split('/')[-1]
video_writer = cv2.VideoWriter(f'results/videos/{name}', cv2.VideoWriter_fourcc(*"mp4v"), target_fps,
(frame_width, frame_height))
progress_bar = ProgressBar(40, num_frames)
timer.reset()
t_fps = 0
for i in range(num_frames):
if i == 1:
timer.start()
frame_origin = vid.read()[1]
img_h, img_w = frame_origin.shape[0:2]
frame_trans = val_aug(frame_origin, cfg.img_size)
frame_tensor = torch.tensor(frame_trans).float()
if cfg.cuda:
frame_tensor = frame_tensor.cuda()
with torch.no_grad(), timer.counter('forward'):
class_p, box_p, coef_p, proto_p = net(frame_tensor.unsqueeze(0))
with timer.counter('nms'):
ids_p, class_p, box_p, coef_p, proto_p = nms(class_p, box_p, coef_p, proto_p, net.anchors, cfg)
with timer.counter('after_nms'):
ids_p, class_p, boxes_p, masks_p = after_nms(ids_p, class_p, box_p, coef_p, proto_p, img_h, img_w, cfg)
with timer.counter('save_img'):
frame_numpy = draw_img(ids_p, class_p, boxes_p, masks_p, frame_origin, cfg, fps=t_fps)
if cfg.real_time:
cv2.imshow('Detection', frame_numpy)
cv2.waitKey(1)
else:
video_writer.write(frame_numpy)
aa = time.perf_counter()
if i > 0:
batch_time = aa - temp
timer.add_batch_time(batch_time)
temp = aa
if i > 0:
t_t, t_d, t_f, t_nms, t_an, t_si = timer.get_times(['batch', 'data', 'forward',
'nms', 'after_nms', 'save_img'])
fps, t_fps = 1 / (t_d + t_f + t_nms + t_an), 1 / t_t
bar_str = progress_bar.get_bar(i + 1)
print(f'\rDetecting: {bar_str} {i + 1}/{num_frames}, fps: {fps:.2f} | total fps: {t_fps:.2f} | '
f't_t: {t_t:.3f} | t_d: {t_d:.3f} | t_f: {t_f:.3f} | t_nms: {t_nms:.3f} | '
f't_after_nms: {t_an:.3f} | t_save_img: {t_si:.3f}', end='')
if not cfg.real_time:
print(f'\n\nFinished, saved in: results/videos/{name}')
vid.release()
video_writer.release()
img_name = img_name.split('.')[0] # only save the filename
print("the {} image : {}".format(i, img_name))
print("img size:", img.shape)
img_h, img_w = img_origin.shape[0:2]
class_p, box_p, coef_p, proto_p, anchors = net(img)
ids_p, class_p, box_p, coef_p, proto_p = nms(class_p, box_p, coef_p, proto_p, anchors, cfg)
ids_p, class_p, boxes_p, masks_p = after_nms(ids_p, class_p, box_p, coef_p,
proto_p, img_h, img_w, cfg, img_name=img_name)
# 种类id, 置信度，bbox[n, 4]，mask[n, img_h, img_w]
print(ids_p.shape, class_p.shape, boxes_p.shape, masks_p.shape)
if args.background:
saveBackground(ids_p, class_p, boxes_p, img_name)
cfg.cutout = False
else:
save(ids_p, class_p, boxes_p, masks_p, img_name)
cfg.cutout = False
# output the image with masks and bounding boxes
# if --cutout set to true, the cutout objects also be saved
# cutout images save to results/image
img_numpy = draw_img(ids_p, class_p, boxes_p, masks_p, img_origin, cfg, img_name=img_name)
cv2.imwrite(f'{args.image}/detect/{img_name}_detect.jpg', img_numpy)
endTime = time.perf_counter()
print(f'Time cost:{endTime-startTime:.3f}s')
labRecord.cutoutSummary()
else:
print("cfg.image is None!")
