def do_detect(img_raw, net, device, cfg):
resize = 1
img = np.float32(img_raw)
im_height, im_width, _ = img.shape
scale = torch.Tensor(
[img.shape[1], img.shape[0], img.shape[1], img.shape[0]])
img -= (104, 117, 123)
img = img.transpose(2, 0, 1)
img = torch.from_numpy(img).unsqueeze(0)
img = img.to(device)
scale = scale.to(device)
tic = time.time()
loc, conf, landms = net(img) # forward pass
print('net forward time: {:.4f}'.format(time.time() - tic))
priorbox = PriorBox(cfg, image_size=(im_height, im_width))
priors = priorbox.forward()
priors = priors.to(device)
prior_data = priors.data
boxes = decode(loc.data.squeeze(0), prior_data, cfg['variance'])
boxes = boxes * scale / resize
boxes = boxes.cpu().numpy()
scores = conf.squeeze(0).data.cpu().numpy()[:, 1]
landms = decode_landm(landms.data.squeeze(0), prior_data, cfg['variance'])
scale1 = torch.Tensor([
img.shape[3], img.shape[2], img.shape[3], img.shape[2], img.shape[3],
img.shape[2], img.shape[3], img.shape[2], img.shape[3], img.shape[2]
])
scale1 = scale1.to(device)
landms = landms * scale1 / resize
landms = landms.cpu().numpy()
# ignore low scores
inds = np.where(scores > args.confidence_threshold)[0]
boxes = boxes[inds]
landms = landms[inds]
scores = scores[inds]
# keep top-K before NMS
order = scores.argsort()[::-1][:args.top_k]
boxes = boxes[order]
landms = landms[order]
scores = scores[order]
# do NMS
dets = np.hstack((boxes, scores[:, np.newaxis])).astype(np.float32,
copy=False)
keep = py_cpu_nms(dets, args.nms_threshold)
# keep = nms(dets, args.nms_threshold,force_cpu=args.cpu)
dets = dets[keep, :]
landms = landms[keep]
# keep top-K faster NMS
dets = dets[:args.keep_top_k, :]
landms = landms[:args.keep_top_k, :]
# dets = np.concatenate((dets, landms), axis=1)
return dets, landms
def parse_det_offset(pos, scale, offset, config):
size, score, down, nms_thresh = config.test_size, config.score_thres, config.stride, config.nms_thres
height = scale[0, :, :]
width = scale[1, :, :]
offset_y = offset[0, :, :]
offset_x = offset[1, :, :]
y_c, x_c = np.where(pos > score)
boxs = []
if len(y_c) > 0:
for i in range(len(y_c)):
h = np.exp(height[y_c[i], x_c[i]]) * down
# w = 0.41 * h
w = np.exp(width[y_c[i], x_c[i]]) * down
o_y = offset_y[y_c[i], x_c[i]]
o_x = offset_x[y_c[i], x_c[i]]
s = pos[y_c[i], x_c[i]]
x1, y1 = max(0, (x_c[i] + o_x + 0.5) * down - w / 2), max(
0, (y_c[i] + o_y + 0.5) * down - h / 2)
boxs.append(
[x1, y1, min(x1 + w, size[1]),
min(y1 + h, size[0]), s])
boxs = np.asarray(boxs, dtype=np.float32)
keep = py_cpu_nms(boxs, nms_thresh)
boxs = boxs[keep, :]
return boxs
def box_handle(img, conf, im_height, im_width, scale, loc, landms):
priorbox = PriorBox(cfg_mnet, image_size=(im_height, im_width))
priors = priorbox.forward()
priors = priors.to(device)
prior_data = priors.data
boxes = decode(loc.data.squeeze(0), prior_data, cfg_mnet['variance'])
boxes = boxes * scale
boxes = boxes.cpu().numpy()
scores = conf.squeeze(0).data.cpu().numpy()[:, 1]
landms = decode_landm(landms.data.squeeze(0), prior_data,
cfg_mnet['variance'])
scale1 = torch.Tensor([
img.shape[3], img.shape[2], img.shape[3], img.shape[2], img.shape[3],
img.shape[2], img.shape[3], img.shape[2], img.shape[3], img.shape[2]
])
scale1 = scale1.to(device)
landms = landms * scale1
landms = landms.cpu().numpy()
inds = np.where(scores > confidence_threshold)[0]
boxes = boxes[inds]
landms = landms[inds]
scores = scores[inds]
order = scores.argsort()[::-1]
boxes = boxes[order]
landms = landms[order]
scores = scores[order]
dets = np.hstack((boxes, scores[:, np.newaxis])).astype(np.float32,
copy=False)
keep = py_cpu_nms(dets, nms_threshold)
dets = dets[keep, :]
landms = landms[keep]
dets = np.concatenate((dets, landms), axis=1)
return dets
def parse_det_offset(output, config):
size, score, down, nms_thresh = config.test_size, config.score_thres, config.stride, config.nms_thres
pos, scale, offset = output
print(pos.shape)
pos = np.squeeze(pos.data.cpu())
height = scale.data.cpu()[0, 0, :, :].numpy()
width = scale.data.cpu()[0, 1, :, :].numpy()
offset_y = offset.data.cpu()[0, 0, :, :].numpy()
offset_x = offset.data.cpu()[0, 1, :, :].numpy()
y_c, x_c = np.where(pos > score)
boxs = []
if len(y_c) > 0:
for i in range(len(y_c)):
h = np.exp(height[y_c[i], x_c[i]]) * down
# w = 0.41 * h
w = np.exp(width[y_c[i], x_c[i]]) * down
o_y = offset_y[y_c[i], x_c[i]]
o_x = offset_x[y_c[i], x_c[i]]
s = pos[y_c[i], x_c[i]]
x1, y1 = max(0, (x_c[i] + o_x + 0.5) * down - w / 2), max(
0, (y_c[i] + o_y + 0.5) * down - h / 2)
boxs.append(
[x1, y1, min(x1 + w, size[1]),
min(y1 + h, size[0]), s])
boxs = np.asarray(boxs, dtype=np.float32)
# keep = nms(boxs, nms_thresh, True) # cpu nms
keep = py_cpu_nms(boxs, nms_thresh)
boxs = boxs[keep, :]
return boxs
def recognition(args):
image = cv2.imread(args.filename)
re_list = HyperLPR_PlateRecogntion(image) # 识别结果
cls_boxes = []
cls_scores = []
if len(re_list) > 0:
for item in re_list:
score, box = item[1], item[2]
cls_scores.append(score)
cls_boxes.append(box)
cls_boxes = np.array(cls_boxes)
cls_scores = np.array(cls_scores)
dets = np.hstack(
(cls_boxes, cls_scores[:, np.newaxis])).astype(np.float32)
NMS_THREASH = 0.45
det_re = py_cpu_nms(dets, NMS_THREASH)
re_list = [re_list[x] for x in det_re]
for item in re_list:
label, probolity, position = item[0], item[1], item[2]
cv2.rectangle(image, (position[0], position[1]),
(position[2], position[3]), (0, 255, 0), 2)
position = (position[0], position[1])
image = draw_chinese(image, position, label)
# cv2.putText(image,label,(position[0],position[1]+10),cv2.FONT_HERSHEY_SIMPLEX,0.8,(255,2,255),2)
image_name = os.path.basename(args.filename)
cv2.imwrite((args.save_dir + "/" + image_name), image)
def execute_batch_mlu(self,net_output,batch_shape,threshold=0.8,topk=5000,keep_topk=750,nms_threshold=0.2):
locs,confs,landmss = net_output
nB, nCh, im_height, im_width = batch_shape
scale = torch.Tensor([im_width, im_height]*2)
scale1 = torch.Tensor([im_width, im_height] * 5)
detss = []
if im_height == self.im_height and im_width == self.im_width and self._priors is not None:
pass
else:
self.set_default_size([im_height, im_width, nCh])
priors = self._priors.unsqueeze(dim=0)
boxes = batch_decode(locs, priors, self.cfg['variance'])
boxes = boxes * scale
scores = confs[:, :, 1]
landms = batch_decode_landm(landmss, priors, self.cfg['variance'])
landms = landms * scale1
landms = landms.data.cpu().numpy()
scores = scores.data.cpu().numpy()
boxes = boxes.data.cpu().numpy()
for n in range(nB):
_landms = landms[n]
_scores = scores[n]
_boxes = boxes[n]
# ignore low scores
inds = np.where(_scores > threshold)[0]
_boxes = _boxes[inds]
_landms = _landms[inds]
_scores = _scores[inds]
# keep top-K before NMS
order = _scores.argsort()[::-1][:topk]
_boxes = _boxes[order]
_landms = _landms[order]
_scores = _scores[order]
# do NMS
dets = np.hstack((_boxes, _scores[:, np.newaxis])).astype(np.float32, copy=False)
keep = py_cpu_nms(dets, nms_threshold)
dets = dets[keep, :]
_landms = _landms[keep]
# keep top-K faster NMS
dets = dets[:keep_topk, :]
_landms = _landms[:keep_topk, :]
# x0,y0,x1,y1,score,landmarks...
dets = np.concatenate((dets, _landms), axis=1)
detss.append(dets)
return detss
def pipeline(net, frame, args, device, resize, cfg):
img = np.float32(frame)
im_height, im_width, _ = img.shape
scale = torch.Tensor(
[img.shape[1], img.shape[0], img.shape[1], img.shape[0]])
img -= (104, 117, 123)
img = img.transpose(2, 0, 1)
img = torch.from_numpy(img).unsqueeze(0)
img = img.to(device)
scale = scale.to(device)
loc, conf, landms = net(img) # forward pass
priorbox = PriorBox(cfg, image_size=(im_height, im_width))
priors = priorbox.forward()
priors = priors.to(device)
prior_data = priors.data
boxes = decode(loc.data.squeeze(0), prior_data, cfg['variance'])
boxes = boxes * scale / resize
boxes = boxes.cpu().numpy()
scores = conf.squeeze(0).data.cpu().numpy()[:, 1]
landms = decode_landm(landms.data.squeeze(0), prior_data, cfg['variance'])
scale1 = torch.Tensor([
img.shape[3], img.shape[2], img.shape[3], img.shape[2], img.shape[3],
img.shape[2], img.shape[3], img.shape[2], img.shape[3], img.shape[2]
])
scale1 = scale1.to(device)
landms = landms * scale1 / resize
landms = landms.cpu().numpy()
# ignore low scores
inds = np.where(scores > args.confidence_threshold)[0]
boxes = boxes[inds]
landms = landms[inds]
scores = scores[inds]
# keep top-K before NMS
order = scores.argsort()[::-1][:args.top_k]
boxes = boxes[order]
landms = landms[order]
scores = scores[order]
# do NMS
dets = np.hstack((boxes, scores[:, np.newaxis])).astype(np.float32,
copy=False)
keep = py_cpu_nms(dets, args.nms_threshold)
dets = dets[keep, :]
landms = landms[keep]
# keep top-K faster NMS
dets = dets[:args.keep_top_k, :]
landms = landms[:args.keep_top_k, :]
dets = np.concatenate((dets, landms), axis=1)
objects_to_draw = dict(draw_box=True, draw_text=True, draw_landmarks=True)
frame = draw(frame, dets, args.vis_thres, **objects_to_draw)
return frame
def process_face_data(cfg,
im,
im_height,
im_width,
loc,
scale,
conf,
landms,
resize,
top_k=5000,
nms_threshold=0.4,
keep_top_k=750):
priorbox = PriorBox(cfg, image_size=(im_height, im_width))
priors = priorbox.forward()
priors = priors.cuda()
priors_data = priors.data
boxes = decode(loc.data.squeeze(0), priors_data, cfg['variance'])
boxes = boxes * scale / resize
boxes = boxes.cpu().numpy()
scores = conf.squeeze(0).cpu().detach().numpy()[:, 1]
landms = decode_landm(landms.data.squeeze(0), priors_data, cfg['variance'])
scale_landm = torch.from_numpy(
np.array([
im.shape[3], im.shape[2], im.shape[3], im.shape[2], im.shape[3],
im.shape[2], im.shape[3], im.shape[2], im.shape[3], im.shape[2]
]))
scale_landm = scale_landm.float()
scale_landm = scale_landm.cuda()
landms = landms * scale_landm / resize
landms = landms.cpu().numpy()
# ignore low score
inds = np.where(scores > 0.6)[0]
boxes = boxes[inds]
scores = scores[inds]
# keep top-K before NMS
order = np.argsort(-scores)[:top_k]
boxes = boxes[order]
landms = landms[order]
scores = scores[order]
# do nms
dets = np.hstack((boxes, scores[:, np.newaxis])).astype(float, copy=False)
keep = py_cpu_nms(dets, nms_threshold)
dets = dets[keep, :]
landms = landms[keep]
# keep top-K fater NMS
dets = dets[:keep_top_k, :]
landms = landms[:keep_top_k, :]
dets = np.concatenate((dets, landms), axis=1)
result_data = dets[:, :5].tolist()
return result_data
def nms(dets, thresh, force_cpu=False):
"""Dispatch to either CPU or GPU NMS implementations."""
if dets.shape[0] == 0:
return []
if force_cpu:
#return cpu_soft_nms(dets, thresh, method = 0)
# return cpu_nms(dets, thresh)
return py_nms.py_cpu_nms(dets, thresh)
return gpu_nms(dets, thresh)
def GetFacialPoints(img_raw):
img = np.float32(img_raw)
height, width, _ = img_raw.shape
scale = torch.Tensor([width, height, width, height])
img -= (104, 117, 123)
img = img.transpose(2, 0, 1)
img = torch.from_numpy(img).unsqueeze(0)
img = img.to(device)
scale = scale.to(device)
loc, conf, landms = net(img) # forward pass
priorbox = PriorBox(cfg, image_size=(height, width))
priors = priorbox.forward()
priors = priors.to(device)
prior_data = priors.data
boxes = decode(loc.data.squeeze(0), prior_data, cfg['variance'])
boxes = boxes * scale / config.resize
boxes = boxes.cpu().detach().numpy()
scores = conf.squeeze(0).data.cpu().detach().numpy()[:, 1]
landms = decode_landm(landms.data.squeeze(0), prior_data, cfg['variance'])
scale1 = torch.Tensor([
img.shape[3], img.shape[2], img.shape[3], img.shape[2], img.shape[3],
img.shape[2], img.shape[3], img.shape[2], img.shape[3], img.shape[2]
])
scale1 = scale1.to(device)
landms = landms * scale1 / config.resize
landms = landms.cpu().detach().numpy()
# ignore low scores
inds = np.where(scores > config.confidence_threshold)[0]
boxes = boxes[inds]
landms = landms[inds]
scores = scores[inds]
# keep top-K before NMS
order = scores.argsort()[::-1][:config.top_k]
boxes = boxes[order]
landms = landms[order]
scores = scores[order]
# do NMS
dets = np.hstack((boxes, scores[:, np.newaxis])).astype(np.float32,
copy=False)
keep = py_cpu_nms(dets, config.nms_threshold)
dets = dets[keep, :]
landms = landms[keep]
# keep top-K faster NMS
dets = dets[:config.keep_top_k, :]
landms = landms[:config.keep_top_k, :]
dets = np.concatenate((dets, landms), axis=1)
torch.cuda.empty_cache()
return dets
def detect_image(self, img) -> List[FaceDetection]:
# TODO: add detect logic for single image
print(np.shape(img))
tic = time.time()
img = np.float32(img)
im_height, im_width, _ = img.shape
scale = torch.Tensor([img.shape[1], img.shape[0], img.shape[1], img.shape[0]])
img -= (104, 117, 123)
img = img.transpose(2, 0, 1)
img = torch.from_numpy(img).unsqueeze(0)
img = img.to(self.device)
scale = scale.to(self.device)
loc, conf, landms = self.net(img) # forward pass
priorbox = PriorBox(self.cfg, image_size=(im_height, im_width))
priors = priorbox.forward()
priors = priors.to(self.device)
prior_data = priors.data
boxes = decode(loc.data.squeeze(0), prior_data, self.cfg['variance'])
boxes = boxes * scale / self.resize
boxes = boxes.cpu().numpy()
scores = conf.squeeze(0).data.cpu().numpy()[:, 1]
# ignore low scores
inds = np.where(scores > args.confidence_threshold)[0]
boxes = boxes[inds]
scores = scores[inds]
# keep top-K before NMS
order = scores.argsort()[::-1][:args.top_k]
boxes = boxes[order]
scores = scores[order]
# do NMS
dets = np.hstack((boxes, scores[:, np.newaxis])).astype(np.float32, copy=False)
keep = py_cpu_nms(dets, args.nms_threshold)
dets = dets[keep, :]
dets = dets[:args.keep_top_k, :]
# show image
box_list = []
for b in dets:
if b[4] < args.vis_thres:
continue
score = b[4]
b = list(map(int, b))
box_list.append(FaceDetection(b[0], b[1], b[2], b[3], 0, score))
print('net forward time: {:.4f}'.format(time.time() - tic))
return box_list
def decode_output(image, detection_boxes, detection_scores, detection_landmark, cfg_plate):
# print(image.shape[2:])
image_h, image_w = image.shape[2:]
# image_h, image_w, _ = image.shape
# cfg_plate['image_size'] = (480, 640)
detection_scores = F.softmax(detection_scores, dim=-1)
# detection_scores = detection_scores.cpu().detach().numpy()
# priorbox = PriorBox(cfg_plate,
# image_size=(cfg_plate['image_size'], cfg_plate['image_size']), phase='test') # height, width
priorbox = PriorBox(cfg_plate,
image_size=(image_h, image_w), phase='test') # height, width
priors = priorbox.forward()
priors = priors.to(torch.device('cuda'))
prior_data = priors.data
boxes = decode(detection_boxes.data.squeeze(0), prior_data, cfg_plate['variance'])
# boxes[:, 0::2] = boxes[:, 0::2] * cfg_plate['image_size'] # width
# boxes[:, 1::2] = boxes[:, 1::2] * cfg_plate['image_size'] # height
boxes[:, 0::2] = boxes[:, 0::2] * image_w # width
boxes[:, 1::2] = boxes[:, 1::2] * image_h # height
boxes = boxes.cpu().numpy()
scores = scores = detection_scores.squeeze(0).data.cpu().numpy()[:, 1]
landms = decode_landm(detection_landmark.data.squeeze(0), prior_data, cfg_plate['variance'])
# landms[:, 0::2] = landms[:, 0::2] * cfg_plate['image_size']
# landms[:, 1::2] = landms[:, 1::2] * cfg_plate['image_size']
landms[:, 0::2] = landms[:, 0::2] * image_w
landms[:, 1::2] = landms[:, 1::2] * image_h
landms = landms.cpu().numpy()
# ignore low scores
inds = np.where(scores > cfg_plate['confidence_threshold'])[0]
boxes = boxes[inds]
landms = landms[inds]
scores = scores[inds]
# keep top-K before NMS
order = scores.argsort()[::-1][:cfg_plate['top_k']]
boxes = boxes[order]
landms = landms[order]
scores = scores[order]
# do NMS
dets = np.hstack((boxes, scores[:, np.newaxis])).astype(np.float32, copy=False)
keep = py_cpu_nms(dets, cfg_plate['nms_threshold'])
# keep = nms(dets, args.nms_threshold,force_cpu=args.cpu)
dets = dets[keep, :]
landms = landms[keep]
# keep top-K faster NMS
dets = dets[:cfg_plate['keep_top_k'], :]
landms = landms[:cfg_plate['keep_top_k'], :]
dets = np.concatenate((dets, landms), axis=1)
# draw_ouput2(image, dets)
return dets
def postproc_frame(boxes: np.ndarray,
scores: np.ndarray,
score_thresh=0.75,
nms_thresh=0.4,
top_k=500,
keep_top_k=5) -> np.ndarray:
inds = (scores > score_thresh).nonzero()[0]
boxes = boxes[inds]
scores = scores[inds]
# keep top-K before NMS
order = scores.argsort()[::-1][:top_k]
boxes = boxes[order]
scores = scores[order]
# do NMS
dets = np.hstack((boxes, scores[:, np.newaxis]))
dets = dets.astype(np.float32, copy=False)
keep = py_cpu_nms(dets, nms_thresh)
dets = dets[keep, :]
# keep top-K faster NMS
dets = dets[:keep_top_k, :]
return dets
def do_inference(net, img_raw):
img = np.float32(img_raw)
im_height, im_width, _ = img.shape
scale = torch.Tensor(
[img.shape[1], img.shape[0], img.shape[1], img.shape[0]])
img -= (104, 117, 123)
img = img.transpose(2, 0, 1)
img = torch.from_numpy(img).unsqueeze(0)
img = img.to(device)
scale = scale.to(device)
tic = time.time()
loc, conf, landms = net(img) # forward pass
print('net forward time: {:.4f}'.format(time.time() - tic))
priorbox = PriorBox(cfg, image_size=(im_height, im_width))
priors = priorbox.forward()
priors = priors.to(device)
prior_data = priors.data
boxes = decode(loc.data.squeeze(0), prior_data, cfg['variance'])
boxes = boxes * scale / resize
boxes = boxes.cpu().numpy()
scores = conf.squeeze(0).data.cpu().numpy()[:, 1]
landms = decode_landm(landms.data.squeeze(0), prior_data, cfg['variance'])
scale1 = torch.Tensor([
img.shape[3], img.shape[2], img.shape[3], img.shape[2], img.shape[3],
img.shape[2], img.shape[3], img.shape[2], img.shape[3], img.shape[2]
])
scale1 = scale1.to(device)
landms = landms * scale1 / resize
landms = landms.cpu().numpy()
# ignore low scores
inds = np.where(scores > args.confidence_threshold)[0]
boxes = boxes[inds]
landms = landms[inds]
scores = scores[inds]
# keep top-K before NMS
order = scores.argsort()[::-1][:args.top_k]
boxes = boxes[order]
landms = landms[order]
scores = scores[order]
# do NMS
dets = np.hstack((boxes, scores[:, np.newaxis])).astype(np.float32,
copy=False)
keep = py_cpu_nms(dets, args.nms_threshold)
# keep = nms(dets, args.nms_threshold,force_cpu=args.cpu)
dets = dets[keep, :]
landms = landms[keep]
# keep top-K faster NMS
dets = dets[:args.keep_top_k, :]
landms = landms[:args.keep_top_k, :]
dets = np.concatenate((dets, landms), axis=1)
# show image
if args.save_image:
for b in dets:
if b[4] < args.vis_thres:
continue
text = "{:.4f}".format(b[4])
b = list(map(int, b))
cv2.rectangle(img_raw, (b[0], b[1]), (b[2], b[3]), (0, 0, 255), 2)
cx = b[0]
cy = b[1] + 12
cv2.putText(img_raw, text, (cx, cy), cv2.FONT_HERSHEY_DUPLEX, 0.5,
(255, 255, 255))
# landms
cv2.circle(img_raw, (b[5], b[6]), 1, (0, 0, 255), 4)
cv2.circle(img_raw, (b[7], b[8]), 1, (0, 255, 255), 4)
cv2.circle(img_raw, (b[9], b[10]), 1, (255, 0, 255), 4)
cv2.circle(img_raw, (b[11], b[12]), 1, (0, 255, 0), 4)
cv2.circle(img_raw, (b[13], b[14]), 1, (255, 0, 0), 4)
def main():
args = get_args()
torch.set_grad_enabled(False)
cfg = None
if args.network == "mobile0.25":
cfg = cfg_mnet
elif args.network == "resnet50":
cfg = cfg_re50
# net and model
net = RetinaFace(cfg=cfg, phase="test")
net = load_model(net, args.trained_model, args.cpu)
net.eval()
print("Finished loading model!")
print(net)
cudnn.benchmark = True
device = torch.device("cpu" if args.cpu else "cuda")
net = net.to(device)
args.save_folder.mkdir(exist_ok=True)
fw = open(os.path.join(args.save_folder, args.dataset + "_dets.txt"), "w")
# testing dataset
testset_folder = os.path.join("data", args.dataset, "images/")
testset_list = os.path.join("data", args.dataset, "img_list.txt")
with open(testset_list, "r") as fr:
test_dataset = fr.read().split()
num_images = len(test_dataset)
# testing scale
resize = 1
_t = {"forward_pass": Timer(), "misc": Timer()}
# testing begin
for i, img_name in enumerate(test_dataset):
image_path = testset_folder + img_name + ".jpg"
img_raw = cv2.imread(image_path, cv2.IMREAD_COLOR)
img = np.float32(img_raw)
if resize != 1:
img = cv2.resize(img,
None,
None,
fx=resize,
fy=resize,
interpolation=cv2.INTER_LINEAR)
im_height, im_width, _ = img.shape
scale = torch.Tensor(
[img.shape[1], img.shape[0], img.shape[1], img.shape[0]])
img -= (104, 117, 123)
img = img.transpose(2, 0, 1)
img = torch.from_numpy(img).unsqueeze(0)
img = img.to(device)
scale = scale.to(device)
_t["forward_pass"].tic()
loc, conf, landms = net(img) # forward pass
_t["forward_pass"].toc()
_t["misc"].tic()
priorbox = PriorBox(cfg, image_size=(im_height, im_width))
priors = priorbox.forward()
priors = priors.to(device)
prior_data = priors.data
boxes = decode(loc.data.squeeze(0), prior_data, cfg["variance"])
boxes = boxes * scale / resize
boxes = boxes.cpu().numpy()
scores = conf.squeeze(0).data.cpu().numpy()[:, 1]
landms = decode_landm(landms.data.squeeze(0), prior_data,
cfg["variance"])
scale1 = torch.Tensor([
img.shape[3],
img.shape[2],
img.shape[3],
img.shape[2],
img.shape[3],
img.shape[2],
img.shape[3],
img.shape[2],
img.shape[3],
img.shape[2],
])
scale1 = scale1.to(device)
landms = landms * scale1 / resize
landms = landms.cpu().numpy()
# ignore low scores
inds = np.where(scores > args.confidence_threshold)[0]
boxes = boxes[inds]
landms = landms[inds]
scores = scores[inds]
# keep top-K before NMS
# order = scores.argsort()[::-1][:args.top_k]
order = scores.argsort()[::-1]
boxes = boxes[order]
landms = landms[order]
scores = scores[order]
# do NMS
dets = np.hstack((boxes, scores[:, np.newaxis])).astype(np.float32,
copy=False)
keep = py_cpu_nms(dets, args.nms_threshold)
dets = dets[keep, :]
landms = landms[keep]
# keep top-K faster NMS
# dets = dets[:args.keep_top_k, :]
# landms = landms[:args.keep_top_k, :]
dets = np.concatenate((dets, landms), axis=1)
_t["misc"].toc()
# save dets
if args.dataset == "FDDB":
fw.write("{:s}\n".format(img_name))
fw.write("{:.1f}\n".format(dets.shape[0]))
for k in range(dets.shape[0]):
xmin = dets[k, 0]
ymin = dets[k, 1]
xmax = dets[k, 2]
ymax = dets[k, 3]
score = dets[k, 4]
w = xmax - xmin + 1
h = ymax - ymin + 1
# fw.write('{:.3f} {:.3f} {:.3f} {:.3f} {:.10f}\n'.format(xmin, ymin, w, h, score))
fw.write("{:d} {:d} {:d} {:d} {:.10f}\n".format(
int(xmin), int(ymin), int(w), int(h), score))
print("im_detect: {:d}/{:d} forward_pass_time: {:.4f}s misc: {:.4f}s".
format(i + 1, num_images, _t["forward_pass"].average_time,
_t["misc"].average_time))
# show image
if args.save_image:
for b in dets:
if b[4] < args.vis_thres:
continue
text = "{:.4f}".format(b[4])
b = list(map(int, b))
cv2.rectangle(img_raw, (b[0], b[1]), (b[2], b[3]), (0, 0, 255),
2)
cx = b[0]
cy = b[1] + 12
cv2.putText(img_raw, text, (cx, cy), cv2.FONT_HERSHEY_DUPLEX,
0.5, (255, 255, 255))
# landms
cv2.circle(img_raw, (b[5], b[6]), 1, (0, 0, 255), 4)
cv2.circle(img_raw, (b[7], b[8]), 1, (0, 255, 255), 4)
cv2.circle(img_raw, (b[9], b[10]), 1, (255, 0, 255), 4)
cv2.circle(img_raw, (b[11], b[12]), 1, (0, 255, 0), 4)
cv2.circle(img_raw, (b[13], b[14]), 1, (255, 0, 0), 4)
# save image
if not os.path.exists("./results/"):
os.makedirs("./results/")
name = "./results/" + str(i) + ".jpg"
cv2.imwrite(name, img_raw)
fw.close()
def get_face_bboxes():
good_dets = {}
for image in tqdm(os.listdir(input_dir)):
img_raw = cv2.imread(str(input_dir / image), cv2.IMREAD_COLOR)
img = np.float32(img_raw)
if resize != 1:
img = cv2.resize(img,
None,
None,
fx=resize,
fy=resize,
interpolation=cv2.INTER_LINEAR)
im_height, im_width, _ = img.shape
scale = torch.Tensor(
[img.shape[1], img.shape[0], img.shape[1], img.shape[0]])
img -= (104, 117, 123)
img = img.transpose(2, 0, 1)
img = torch.from_numpy(img).unsqueeze(0)
img = img.to(device)
scale = scale.to(device)
_t[forward_pass_det].tic()
loc, conf, _ = net(img) # forward pass
_t[forward_pass_det].toc()
_t[misc_det].tic()
priorbox = PriorBox(cfg, image_size=(im_height, im_width))
priors = priorbox.forward()
priors = priors.to(device)
prior_data = priors.data
boxes = decode(loc.data.squeeze(0), prior_data, cfg["variance"])
boxes = boxes * scale / resize
boxes = boxes.cpu().numpy()
scores = conf.squeeze(0).data.cpu().numpy()[:, 1]
# ignore low scores
inds = np.where(scores > confidence_threshold)[0]
boxes = boxes[inds]
# landms = landms[inds]
scores = scores[inds]
# keep top-K before NMS
order = scores.argsort()[::-1]
# order = scores.argsort()[::-1][:args.top_k]
boxes = boxes[order]
# landms = landms[order]
scores = scores[order]
# do NMS
dets = np.hstack((boxes, scores[:, np.newaxis])).astype(np.float32,
copy=False)
keep = py_cpu_nms(dets, nms_threshold)
# keep = nms(dets, args.nms_threshold,force_cpu=args.cpu)
dets = dets[keep, :]
# landms = landms[keep]
good_det = []
for b in dets:
if b[4] < vis_thres:
continue
good_det.append(b)
good_dets[image] = good_det
_t[misc_det].toc()
print("im_detect: [forward_pass_time: {:.4f}s misc: {:.4f}s] per image".
format(_t[forward_pass_det].average_time, _t[misc_det].average_time))
return good_dets
def detect(self, frame):
resize = 1
img = np.float32(frame)
im_height, im_width, _ = img.shape
scale = torch.Tensor([im_width, im_height, im_width, im_height])
img -= (104, 117, 123)
img = img.transpose(2, 0, 1)
img = torch.from_numpy(img).unsqueeze(0)
img = img.to(self.device)
scale = scale.to(self.device)
loc, conf, landms = self.net(img)
priorbox = PriorBox(self.cfg, image_size=(im_height, im_width))
priors = priorbox.forward()
priors = priors.to(self.device)
prior_data = priors.data
boxes = decode(loc.data.squeeze(0), prior_data, self.cfg['variance'])
boxes = boxes * scale / resize
boxes = boxes.cpu().numpy()
scores = conf.squeeze(0).data.cpu().numpy()[:, 1]
landms = decode_landm(landms.data.squeeze(
0), prior_data, self.cfg['variance'])
scale1 = torch.Tensor([img.shape[3], img.shape[2], img.shape[3], img.shape[2],
img.shape[3], img.shape[2], img.shape[3], img.shape[2],
img.shape[3], img.shape[2]])
scale1 = scale1.to(self.device)
landms = landms * scale1 / resize
landms = landms.cpu().numpy()
# ignore low scores
inds = np.where(scores > self.confidence)[0]
boxes = boxes[inds]
landms = landms[inds]
scores = scores[inds]
# keep top-K before NMS
order = scores.argsort()[::-1][:self.top_k]
boxes = boxes[order]
landms = landms[order]
scores = scores[order]
# do NMS
dets = np.hstack((boxes, scores[:, np.newaxis])).astype(
np.float32, copy=False)
keep = py_cpu_nms(dets, self.nms_thresh)
# keep = nms(dets, args.nms_threshold,force_cpu=args.cpu)
dets = dets[keep, :]
landms = landms[keep]
# keep top-K faster NMS
dets = dets[:self.keep_top_k, :]
landms = landms[:self.keep_top_k, :]
dets = np.concatenate((dets, landms), axis=1)
results = []
for det in dets:
r = {}
r["point"] = {}
r["point"]["x1"] = int(det[0])
r["point"]["y1"] = int(det[1])
r["point"]["x2"] = int(det[2])
r["point"]["y2"] = int(det[3])
r["confidence"] = det[4]
r["landmark"] = {}
r["landmark"]["p1_x"] = int(det[5])
r["landmark"]["p1_y"] = int(det[6])
r["landmark"]["p2_x"] = int(det[7])
r["landmark"]["p2_y"] = int(det[8])
r["landmark"]["p3_x"] = int(det[9])
r["landmark"]["p3_y"] = int(det[10])
r["landmark"]["p4_x"] = int(det[11])
r["landmark"]["p4_y"] = int(det[12])
r["landmark"]["p5_x"] = int(det[13])
r["landmark"]["p5_y"] = int(det[14])
results.append(r)
return results
def face_detector(frame):
img_raw = frame.copy()
img = np.float32(img_raw)
if resize != 1:
img = cv2.resize(img,
None,
None,
fx=resize,
fy=resize,
interpolation=cv2.INTER_LINEAR)
im_height, im_width, _ = img.shape
scale = torch.Tensor(
[img.shape[1], img.shape[0], img.shape[1], img.shape[0]])
img -= (104, 117, 123)
img = img.transpose(2, 0, 1)
img = torch.from_numpy(img).unsqueeze(0)
img = img.to(device)
scale = scale.to(device)
loc, conf, landms = net(img) # forward pass
priorbox = PriorBox(cfg, image_size=(im_height, im_width))
priors = priorbox.forward()
priors = priors.to(device)
prior_data = priors.data
boxes = decode(loc.data.squeeze(0), prior_data, cfg['variance'])
boxes = boxes * scale / resize
boxes = boxes.cpu().numpy()
scores = conf.squeeze(0).data.cpu().numpy()[:, 1]
landms = decode_landm(landms.data.squeeze(0), prior_data, cfg['variance'])
scale1 = torch.Tensor([
img.shape[3], img.shape[2], img.shape[3], img.shape[2], img.shape[3],
img.shape[2], img.shape[3], img.shape[2], img.shape[3], img.shape[2]
])
scale1 = scale1.to(device)
landms = landms * scale1 / resize
landms = landms.cpu().numpy()
# ignore low scores
inds = np.where(scores > CONFIDENCE)[0]
boxes = boxes[inds]
landms = landms[inds]
scores = scores[inds]
# keep top-K before NMS
order = scores.argsort()[::-1][:5000]
boxes = boxes[order]
landms = landms[order]
scores = scores[order]
# do NMS
dets = np.hstack((boxes, scores[:, np.newaxis])).astype(np.float32,
copy=False)
keep = py_cpu_nms(dets, NMS_THRESHOLD)
# keep = nms(dets, args.nms_threshold,force_cpu=args.cpu)
dets = dets[keep, :]
landms = landms[keep]
# keep top-K faster NMS
dets = dets[:750, :]
landms = landms[:750, :]
dets = np.concatenate((dets, landms), axis=1)
bboxs = []
for b in dets:
if b[4] < VIZ_THRESHOLD:
continue
b = list(map(int, b))
margin = 5
x1, y1, x2, y2 = b[0], b[1], b[2], b[3]
img_h, img_w, _ = frame.shape
w = x2 - x1
h = y2 - y1
margin = int(min(w, h) * margin / 100)
x_a = x1 - margin
y_a = y1 - margin
x_b = x1 + w + margin
y_b = y1 + h + margin
if x_a < 0:
x_b = min(x_b - x_a, img_w - 1)
x_a = 0
if y_a < 0:
y_b = min(y_b - y_a, img_h - 1)
y_a = 0
if x_b > img_w:
x_a = max(x_a - (x_b - img_w), 0)
x_b = img_w
if y_b > img_h:
y_a = max(y_a - (y_b - img_h), 0)
y_b = img_h
name = ""
face = frame[y_a:y_b, x_a:x_b]
rgb = cv2.cvtColor(face, cv2.COLOR_BGR2RGB)
encodings = face_recognition.face_encodings(rgb,
[(y_a, x_b, y_b, x_a)])
matches = face_recognition.compare_faces(face_data["encodings"],
encodings[0],
tolerance=0.55)
if True in matches:
matchedIdxs = [i for (i, b) in enumerate(matches) if b]
counts = {}
for i in matchedIdxs:
name = face_data["names"][i]
counts[name] = counts.get(name, 0) + 1
name = max(counts, key=counts.get)
cv2.putText(img_raw, name, (x_a + 10, y_a), cv2.FONT_HERSHEY_SIMPLEX,
1, (255, 0, 255), 1, cv2.LINE_AA)
cv2.rectangle(img_raw, (x_a, y_a), (x_b, y_b), (255, 0, 0), 1)
bboxs.append([x_a, y_a, x_b, y_b])
return img_raw, bboxs
def Predict(self,
img_path="test.jpg",
thresh=0.5,
out_img_path="result.jpg"):
image_path = img_path
confidence_threshold = thresh
vis_thres = thresh
nms_threshold = 0.4
top_k = 1000
keep_top_k = 750
save_image = True
name = out_img_path
device = self.system_dict["local"]["device"]
net = self.system_dict["local"]["net"]
cfg = self.system_dict["local"]["cfg"]
resize = 1
img_raw = cv2.imread(image_path, cv2.IMREAD_COLOR)
img = np.float32(img_raw)
im_height, im_width, _ = img.shape
scale = torch.Tensor(
[img.shape[1], img.shape[0], img.shape[1], img.shape[0]])
img -= (104, 117, 123)
img = img.transpose(2, 0, 1)
img = torch.from_numpy(img).unsqueeze(0)
img = img.to(device)
scale = scale.to(device)
tic = time.time()
loc, conf, landms = net(img) # forward pass
print('net forward time: {:.4f}'.format(time.time() - tic))
priorbox = PriorBox(cfg, image_size=(im_height, im_width))
priors = priorbox.forward()
priors = priors.to(device)
prior_data = priors.data
boxes = decode(loc.data.squeeze(0), prior_data, cfg['variance'])
boxes = boxes * scale / resize
boxes = boxes.cpu().numpy()
scores = conf.squeeze(0).data.cpu().numpy()[:, 1]
landms = decode_landm(landms.data.squeeze(0), prior_data,
cfg['variance'])
scale1 = torch.Tensor([
img.shape[3], img.shape[2], img.shape[3], img.shape[2],
img.shape[3], img.shape[2], img.shape[3], img.shape[2],
img.shape[3], img.shape[2]
])
scale1 = scale1.to(device)
landms = landms * scale1 / resize
landms = landms.cpu().numpy()
# ignore low scores
inds = np.where(scores > confidence_threshold)[0]
boxes = boxes[inds]
landms = landms[inds]
scores = scores[inds]
# keep top-K before NMS
order = scores.argsort()[::-1][:top_k]
boxes = boxes[order]
landms = landms[order]
scores = scores[order]
# do NMS
dets = np.hstack((boxes, scores[:, np.newaxis])).astype(np.float32,
copy=False)
keep = py_cpu_nms(dets, nms_threshold)
# keep = nms(dets, args.nms_threshold,force_cpu=args.cpu)
dets = dets[keep, :]
landms = landms[keep]
# keep top-K faster NMS
dets = dets[:keep_top_k, :]
landms = landms[:keep_top_k, :]
dets = np.concatenate((dets, landms), axis=1)
# show image
tmp = {}
tmp["scores"] = []
tmp["bboxes"] = []
tmp["labels"] = []
for b in dets:
if b[4] < vis_thres:
continue
text = "{:.4f}".format(b[4])
b = list(map(int, b))
cv2.rectangle(img_raw, (b[0], b[1]), (b[2], b[3]), (0, 0, 255), 2)
cx = b[0]
cy = b[1] + 12
cv2.putText(img_raw, text, (cx, cy), cv2.FONT_HERSHEY_DUPLEX, 0.5,
(255, 255, 255))
tmp["scores"].append(b[4])
tmp["bboxes"].append([b[0], b[1], b[2], b[3]])
tmp["labels"].append(text)
# landms
#cv2.circle(img_raw, (b[5], b[6]), 1, (0, 0, 255), 4)
#cv2.circle(img_raw, (b[7], b[8]), 1, (0, 255, 255), 4)
#cv2.circle(img_raw, (b[9], b[10]), 1, (255, 0, 255), 4)
#cv2.circle(img_raw, (b[11], b[12]), 1, (0, 255, 0), 4)
#cv2.circle(img_raw, (b[13], b[14]), 1, (255, 0, 0), 4)
# save image
if save_image:
cv2.imwrite(name, img_raw)
return tmp
def crop_face(net,
device,
cfg,
data_dir,
target_dir,
left_scale=0.0,
right_scale=0.0,
up_scale=0.0,
low_scale=0.0):
resize = 1
landmark_target_dir = target_dir + '_landmark'
# testing begin
for dir, dirs, files in tqdm.tqdm(os.walk(data_dir)):
new_dir = dir.replace(data_dir, target_dir)
new_landmark_dir = dir.replace(data_dir, landmark_target_dir)
if not os.path.isdir(new_dir):
os.mkdir(new_dir)
if not os.path.isdir(new_landmark_dir):
os.mkdir(new_landmark_dir)
for file in files:
filepath = os.path.join(dir, file)
# print(filepath)
image_path = filepath
img_raw = cv2.imread(image_path, cv2.IMREAD_COLOR)
if img_raw is None:
continue
im_height, im_width, _ = img_raw.shape
# print(img_raw.shape)
scale_with = 640
scale_height = 480
if im_height > scale_height:
scale_rate = scale_height / im_height
img_raw = cv2.resize(
img_raw, (int(im_width * scale_rate), scale_height))
elif im_width > scale_with:
scale_rate = scale_with / im_width
img_raw = cv2.resize(img_raw,
(scale_with, int(im_height * scale_rate)))
img = np.float32(img_raw)
im_height, im_width, _ = img.shape
scale = torch.Tensor(
[img.shape[1], img.shape[0], img.shape[1], img.shape[0]])
img -= (104, 117, 123)
img = img.transpose(2, 0, 1)
img = torch.from_numpy(img).unsqueeze(0)
img = img.to(device)
scale = scale.to(device)
# tic = time.time()
loc, conf, landms = net(img) # forward pass
# print('net forward time: {:.4f}'.format(time.time() - tic))
priorbox = PriorBox(cfg, image_size=(im_height, im_width))
priors = priorbox.forward()
priors = priors.to(device)
prior_data = priors.data
boxes = decode(loc.data.squeeze(0), prior_data, cfg['variance'])
boxes = boxes * scale / resize
boxes = boxes.cpu().numpy()
scores = conf.squeeze(0).data.cpu().numpy()[:, 1]
landms = decode_landm(landms.data.squeeze(0), prior_data,
cfg['variance'])
scale1 = torch.Tensor([
img.shape[3], img.shape[2], img.shape[3], img.shape[2],
img.shape[3], img.shape[2], img.shape[3], img.shape[2],
img.shape[3], img.shape[2]
])
scale1 = scale1.to(device)
landms = landms * scale1 / resize
landms = landms.cpu().numpy()
# ignore low scores
inds = np.where(scores > args.confidence_threshold)[0]
boxes = boxes[inds]
landms = landms[inds]
scores = scores[inds]
# keep top-K before NMS
order = scores.argsort()[::-1][:args.top_k]
boxes = boxes[order]
landms = landms[order]
scores = scores[order]
# do NMS
dets = np.hstack((boxes, scores[:, np.newaxis])).astype(np.float32,
copy=False)
keep = py_cpu_nms(dets, args.nms_threshold)
# keep = nms(dets, args.nms_threshold,force_cpu=args.cpu)
dets = dets[keep, :]
landms = landms[keep]
# keep top-K faster NMS
dets = dets[:args.keep_top_k, :]
landms = landms[:args.keep_top_k, :]
dets = np.concatenate((dets, landms), axis=1)
# save image
if args.save_image:
max_bb = 0
max_index = 0
if len(dets) == 0:
continue
elif len(dets) > 1:
print('warning detect more than one:', filepath)
# find maximum bounding box
for di, b in enumerate(dets):
if b[4] < args.vis_thres:
continue
b = list(map(int, b))
b = [p if p > 0 else 0 for p in b]
box_w = abs(b[1] - b[3])
box_h = abs(b[0] - b[2])
if max_bb < max(box_w, box_h):
max_bb = max(box_w, box_h)
max_index = di
di = max_index
b = list(map(int, dets[max_index]))
# for di, b in enumerate(dets):
# if b[4] < args.vis_thres:
# continue
# text = "{:.4f}".format(b[4])
# b = list(map(int, b))
# # print(b[0], b[1])
# # print(b[2], b[3])
b = [p if p > 0 else 0 for p in b]
b[1] -= int((b[3] - b[1]) * up_scale)
b[3] += int((b[3] - b[1]) * low_scale)
b[0] -= int((b[2] - b[0]) * left_scale)
b[2] += int((b[2] - b[0]) * right_scale)
b[1] = b[1] if b[1] >= 0 else 0
b[3] = b[3] if b[3] < im_height else im_height - 1
b[0] = b[0] if b[0] >= 0 else 0
b[2] = b[2] if b[2] < im_width else im_width - 1
# retain background
b_width = b[2] - b[0]
b_height = b[3] - b[1]
if b_width > b_height:
b[1] -= abs(b_width - b_height) // 2
b[3] += abs(b_width - b_height) // 2
elif b_width < b_height:
b[0] -= abs(b_width - b_height) // 2
b[2] += abs(b_width - b_height) // 2
b[1] = b[1] if b[1] >= 0 else 0
b[3] = b[3] if b[3] < im_height else im_height - 1
b[0] = b[0] if b[0] >= 0 else 0
b[2] = b[2] if b[2] < im_width else im_width - 1
roi_image = np.copy(img_raw[b[1]:b[3], b[0]:b[2]])
box_w = abs(b[1] - b[3])
box_h = abs(b[0] - b[2])
# print(b[1], b[3])
# print(b[0], b[2])
# print(box_w, box_h)
show_image = roi_image.copy()
leftEyeCenter = (int(landms[di][0] - b[0]),
int(landms[di][1] - b[1]))
rightEyeCenter = (int(landms[di][2] - b[0]),
int(landms[di][3] - b[1]))
noseCenter = (int(landms[di][4] - b[0]),
int(landms[di][5] - b[1]))
mouth1 = (int(landms[di][6] - b[0]), int(landms[di][7] - b[1]))
mouth2 = (int(landms[di][8] - b[0]), int(landms[di][9] - b[1]))
cv2.circle(show_image, (leftEyeCenter[0], leftEyeCenter[1]), 3,
(0, 255, 0), -1)
cv2.circle(show_image, (rightEyeCenter[0], rightEyeCenter[1]),
3, (0, 255, 0), -1)
cv2.circle(show_image, (noseCenter[0], noseCenter[1]), 3,
(0, 255, 0), -1)
cv2.circle(show_image, (mouth1[0], mouth1[1]), 3, (0, 255, 0),
-1)
cv2.circle(show_image, (mouth2[0], mouth2[1]), 3, (0, 255, 0),
-1)
# compute the angle between the eye centroids
eye_dis = np.sqrt((leftEyeCenter[0] - rightEyeCenter[0])**2 +
(leftEyeCenter[1] - rightEyeCenter[1])**2)
# print('eye_dis:', eye_dis)
if eye_dis < 16.0:
angle = 0
else:
dY = rightEyeCenter[1] - leftEyeCenter[1]
dX = rightEyeCenter[0] - leftEyeCenter[0]
angle = np.degrees(np.arctan2(dY, dX))
# print('angle:', angle)
desiredLeftEye = (1.0, 1.0)
desiredFaceWidth = roi_image.shape[1]
desiredFaceHeight = roi_image.shape[0]
# compute the desired right eye x-coordinate based on the
# desired x-coordinate of the left eye
desiredRightEyeX = 1.0 - desiredLeftEye[0]
# determine the scale of the new resulting image by taking
# the ratio of the distance between eyes in the *current*
# image to the ratio of distance between eyes in the
# *desired* image
# dist = np.sqrt((dX ** 2) + (dY ** 2))
# desiredDist = (desiredRightEyeX - desiredLeftEye[0])
# desiredDist *= desiredFaceWidth
# scale = desiredDist / dist
scale = desiredFaceWidth / max(roi_image.shape[:2])
resize_roi_image = cv2.resize(
roi_image, (int(roi_image.shape[1] * scale),
int(roi_image.shape[0] * scale)))
# cv2.imshow('resize_roi_image', resize_roi_image)
# print(max(roi_image.shape))
# print(scale)
# compute center (x, y)-coordinates (i.e., the median point)
# between the two eyes in the input image
eyesCenter = ((leftEyeCenter[0] + rightEyeCenter[0]) // 2,
(leftEyeCenter[1] + rightEyeCenter[1]) // 2)
# grab the rotation matrix for rotating and scaling the face
M = cv2.getRotationMatrix2D(eyesCenter, angle, 1.0)
# apply the affine transformation
(w, h) = (desiredFaceWidth, desiredFaceHeight)
aligned_image = cv2.warpAffine(roi_image,
M, (w, h),
flags=cv2.INTER_CUBIC)
if box_h < box_w:
padding_size = abs(box_w - box_h) // 2
aligned_image = cv2.copyMakeBorder(aligned_image,
0,
0,
padding_size,
padding_size,
cv2.BORDER_CONSTANT,
value=[0, 0, 0])
elif box_h > box_w:
padding_size = abs(box_w - box_h) // 2
aligned_image = cv2.copyMakeBorder(aligned_image,
padding_size,
padding_size,
0,
0,
cv2.BORDER_CONSTANT,
value=[0, 0, 0])
new_image = cv2.resize(aligned_image, (112, 112),
interpolation=cv2.INTER_AREA)
new_path = filepath.replace(data_dir, target_dir)
new_landmark_path = filepath.replace(data_dir,
landmark_target_dir)
new_path = new_path.replace(new_path.split('.')[-1], 'jpg')
new_landmark_path = new_landmark_path.replace(
new_landmark_path.split('.')[-1], 'jpg')
# print(new_path)
cv2.imwrite(new_path, new_image)
def detect_faces(ops, img_raw):
img = np.float32(img_raw)
if ops.resize != 1:
img = cv2.resize(img,
None,
None,
fx=resize,
fy=resize,
interpolation=cv2.INTER_LINEAR)
im_height, im_width, _ = img.shape
scale = torch.Tensor(
[img.shape[1], img.shape[0], img.shape[1], img.shape[0]])
img -= ops.color_mean
img = img.transpose(2, 0, 1)
img = torch.from_numpy(img).unsqueeze(0)
img = img.to(device)
scale = scale.to(device)
loc, conf, landms = detect_model(img) # forward pass
priorbox = PriorBox(cfg, image_size=(im_height, im_width))
priors = priorbox.forward()
priors = priors.to(device)
prior_data = priors.data
boxes = decode(loc.data.squeeze(0), prior_data, cfg['variance'])
boxes = boxes * scale / ops.resize
boxes = boxes.cpu().numpy()
scores = conf.squeeze(0).data.cpu().numpy()[:, 1]
landms = decode_landm(landms.data.squeeze(0), prior_data, cfg['variance'])
scale1 = torch.Tensor([
img.shape[3], img.shape[2], img.shape[3], img.shape[2], img.shape[3],
img.shape[2], img.shape[3], img.shape[2], img.shape[3], img.shape[2]
])
scale1 = scale1.to(device)
landms = landms * scale1 / ops.resize
landms = landms.cpu().numpy()
# ignore low scores
inds = np.where(scores > ops.confidence_threshold)[0]
boxes = boxes[inds]
landms = landms[inds]
scores = scores[inds]
# keep top-K before NMS
order = scores.argsort()[::-1][:ops.keep_top_k]
# order = scores.argsort()[::-1]
boxes = boxes[order]
landms = landms[order]
scores = scores[order]
# do NMS
dets = np.hstack((boxes, scores[:, np.newaxis])).astype(np.float32,
copy=False)
keep = py_cpu_nms(dets, ops.nms_threshold)
dets = dets[keep, :]
landms = landms[keep]
dets = np.concatenate((dets, landms), axis=1)
return dets
def main():
cfg = None
if args.network == "mobile0.25":
cfg = cfg_mnet
elif args.network == "resnet18":
cfg = cfg_re18
elif args.network == "resnet34":
cfg = cfg_re34
elif args.network == "resnet50":
cfg = cfg_re50
elif args.network == "Efficientnet-b0":
cfg = cfg_eff_b0
elif args.network == "Efficientnet-b4":
cfg = cfg_eff_b4
# net and model
net = RetinaFace(cfg=cfg, phase='test')
net = load_model(net, args.trained_model, args.cpu)
net.eval()
print('Finished loading model!')
print(net)
cudnn.benchmark = True
device = torch.device("cpu" if args.cpu else "cuda")
net = net.to(device)
# testing dataset
testset_folder = args.dataset_folder
# testset_list = args.dataset_folder[:-7] + "wider_val.txt"
# with open(testset_list, 'r') as fr:
# test_dataset = fr.read().split()
test_dataset = []
for event in os.listdir(testset_folder):
subdir = os.path.join(testset_folder, event)
img_names = os.listdir(subdir)
for img_name in img_names:
test_dataset.append([event, os.path.join(subdir, img_name)])
num_images = len(test_dataset)
_t = {'forward_pass': Timer(), 'misc': Timer()}
# testing begin
for i, (event, img_name) in enumerate(test_dataset):
if i % 100 == 0:
torch.cuda.empty_cache()
# image_path = testset_folder + img_name
img_raw = cv2.imread(img_name, cv2.IMREAD_COLOR)
img = np.float32(img_raw)
# testing scale
target_size = 480
max_size = 2150
im_shape = img.shape
im_size_min = np.min(im_shape[0:2])
im_size_max = np.max(im_shape[0:2])
resize = float(target_size) / float(im_size_min)
# prevent bigger axis from being more than max_size:
if np.round(resize * im_size_max) > max_size:
resize = float(max_size) / float(im_size_max)
if args.origin_size:
resize = 1
if resize != 1:
img = cv2.resize(img,
None,
None,
fx=resize,
fy=resize,
interpolation=cv2.INTER_LINEAR)
im_height, im_width, _ = img.shape
scale = torch.Tensor(
[img.shape[1], img.shape[0], img.shape[1], img.shape[0]])
img = (img - 127.5) / 128.0
# img -= (104, 117, 123)
img = img.transpose(2, 0, 1)
img = torch.from_numpy(img).unsqueeze(0)
img = img.to(device)
scale = scale.to(device)
_t['forward_pass'].tic()
loc, conf, landms = net(img) # forward pass
_t['forward_pass'].toc()
_t['misc'].tic()
priorbox = PriorBox(cfg, image_size=(im_height, im_width))
priors = priorbox.forward()
priors = priors.to(device)
prior_data = priors.data
boxes = decode(loc.data.squeeze(0), prior_data, cfg['variance'])
boxes = boxes * scale / resize
boxes = boxes.cpu().numpy()
scores = conf.squeeze(0).data.cpu().numpy()[:, 1]
landms = decode_landm(landms.data.squeeze(0), prior_data,
cfg['variance'])
scale1 = torch.Tensor([
img.shape[3], img.shape[2], img.shape[3], img.shape[2],
img.shape[3], img.shape[2], img.shape[3], img.shape[2],
img.shape[3], img.shape[2]
])
scale1 = scale1.to(device)
landms = landms * scale1 / resize
landms = landms.cpu().numpy()
# ignore low scores
inds = np.where(scores > args.confidence_threshold)[0]
boxes = boxes[inds]
landms = landms[inds]
scores = scores[inds]
# keep top-K before NMS
order = scores.argsort()[::-1]
# order = scores.argsort()[::-1][:args.top_k]
boxes = boxes[order]
landms = landms[order]
scores = scores[order]
# do NMS
dets = np.hstack((boxes, scores[:, np.newaxis])).astype(np.float32,
copy=False)
keep = py_cpu_nms(dets, args.nms_threshold)
# keep = nms(dets, args.nms_threshold,force_cpu=args.cpu)
dets = dets[keep, :]
landms = landms[keep]
# keep top-K faster NMS
# dets = dets[:args.keep_top_k, :]
# landms = landms[:args.keep_top_k, :]
dets = np.concatenate((dets, landms), axis=1)
_t['misc'].toc()
# --------------------------------------------------------------------
# save_name = args.save_folder + img_name[:-4] + ".txt"
save_name = os.path.join(
args.save_folder, event,
img_name.split('/')[-1].split('.')[0] + ".txt")
dirname = os.path.dirname(save_name)
if not os.path.isdir(dirname):
os.makedirs(dirname)
with open(save_name, "w") as fd:
bboxs = dets
file_name = os.path.basename(save_name)[:-4] + "\n"
bboxs_num = str(len(bboxs)) + "\n"
fd.write(file_name)
fd.write(bboxs_num)
for box in bboxs:
x = int(box[0])
y = int(box[1])
w = int(box[2]) - int(box[0])
h = int(box[3]) - int(box[1])
confidence = str(box[4])
line = str(x) + " " + str(y) + " " + str(w) + " " + str(
h) + " " + confidence + " \n"
fd.write(line)
print('im_detect: {:d}/{:d} forward_pass_time: {:.4f}s misc: {:.4f}s'.
format(i + 1, num_images, _t['forward_pass'].average_time,
_t['misc'].average_time))
# save image
if args.save_image:
for b in dets:
if b[4] < args.vis_thres:
continue
text = "{:.4f}".format(b[4])
b = list(map(int, b))
cv2.rectangle(img_raw, (b[0], b[1]), (b[2], b[3]), (0, 0, 255),
2)
cx = b[0]
cy = b[1] + 12
cv2.putText(img_raw, text, (cx, cy), cv2.FONT_HERSHEY_DUPLEX,
0.5, (255, 255, 255))
# landms
cv2.circle(img_raw, (b[5], b[6]), 1, (0, 0, 255), 4)
cv2.circle(img_raw, (b[7], b[8]), 1, (0, 255, 255), 4)
cv2.circle(img_raw, (b[9], b[10]), 1, (255, 0, 255), 4)
cv2.circle(img_raw, (b[11], b[12]), 1, (0, 255, 0), 4)
cv2.circle(img_raw, (b[13], b[14]), 1, (255, 0, 0), 4)
# save image
if not os.path.exists("./results/"):
os.makedirs("./results/")
name = "./results/" + str(i) + ".jpg"
cv2.imwrite(name, img_raw)
inds = np.where(scores > 0.02)[0]
boxes = boxes[inds]
landms = landms[inds]
scores = scores[inds]
# keep top-K before NMS
order = scores.argsort()[::-1]
# order = scores.argsort()[::-1][:args.top_k]
boxes = boxes[order]
landms = landms[order]
scores = scores[order]
# do NMS
dets = np.hstack((boxes, scores[:, np.newaxis])).astype(np.float32,
copy=False)
keep = py_cpu_nms(dets, 0.4)
# keep = nms(dets, args.nms_threshold,force_cpu=args.cpu)
dets = dets[keep, :]
landms = landms[keep]
# keep top-K faster NMS
dets = dets[:keep_top_k, :]
landms = landms[:keep_top_k, :]
# take only dets with confident > 0.85
face_conf_mask = dets[:, -1] > 0.85
dets = dets[face_conf_mask, :]
landms = landms[face_conf_mask, :]
# added lanmarks
if len(landms) == 0:
def detect_one_image(name, input_path, output_path):
image_path = os.path.join(input_path, name)
img_raw = cv2.imread(image_path, cv2.IMREAD_COLOR)
img = np.float32(img_raw)
# testing scale
target_size = long_side
max_size = long_side
im_shape = img.shape
im_size_min = np.min(im_shape[0:2])
im_size_max = np.max(im_shape[0:2])
resize = float(target_size) / float(im_size_min)
# prevent bigger axis from being more than max_size:
if np.round(resize * im_size_max) > max_size:
resize = float(max_size) / float(im_size_max)
if origin_size:
resize = 1
if resize != 1:
img = cv2.resize(img,
None,
None,
fx=resize,
fy=resize,
interpolation=cv2.INTER_LINEAR)
im_height, im_width, _ = img.shape
scale = torch.Tensor(
[img.shape[1], img.shape[0], img.shape[1], img.shape[0]])
img -= (104, 117, 123)
img = img.transpose(2, 0, 1)
img = torch.from_numpy(img).unsqueeze(0)
img = img.to(device)
scale = scale.to(device)
tic = time.time()
loc, conf, landms = net(img) # forward pass
print('Inferece {} take: {:.4f}'.format(name, time.time() - tic))
priorbox = PriorBox(cfg, image_size=(im_height, im_width))
priors = priorbox.forward()
priors = priors.to(device)
prior_data = priors.data
boxes = decode(loc.data.squeeze(0), prior_data, cfg['variance'])
boxes = boxes * scale / resize
boxes = boxes.cpu().numpy()
scores = conf.squeeze(0).data.cpu().numpy()[:, 1]
landms = decode_landm(landms.data.squeeze(0), prior_data, cfg['variance'])
scale1 = torch.Tensor([
img.shape[3], img.shape[2], img.shape[3], img.shape[2], img.shape[3],
img.shape[2], img.shape[3], img.shape[2], img.shape[3], img.shape[2]
])
scale1 = scale1.to(device)
landms = landms * scale1 / resize
landms = landms.cpu().numpy()
# ignore low scores
inds = np.where(scores > confidence_threshold)[0]
boxes = boxes[inds]
landms = landms[inds]
scores = scores[inds]
# keep top-K before NMS
order = scores.argsort()[::-1][:top_k]
boxes = boxes[order]
landms = landms[order]
scores = scores[order]
# do NMS
dets = np.hstack((boxes, scores[:, np.newaxis])).astype(np.float32,
copy=False)
keep = py_cpu_nms(dets, nms_threshold)
# keep = nms(dets, args.nms_threshold,force_cpu=args.cpu)
dets = dets[keep, :]
landms = landms[keep]
# keep top-K faster NMS
dets = dets[:keep_top_k, :]
landms = landms[:keep_top_k, :]
dets = np.concatenate((dets, landms), axis=1)
# show image
bbox_res = {}
bbox_res[name] = []
if save_image:
for b in dets:
if b[4] < vis_thres:
continue
text = "{:.4f}".format(b[4])
b = list(map(int, b))
x, y, x_plus_w, y_plus_h = b[0], b[1], b[2], b[3]
bbox_res[name].append({
'x': x,
'y': y,
'w': x_plus_w - x,
'h': y_plus_h - y
})
# Blur face
# sub_face = img_raw[y:y_plus_h, x:x_plus_w]
# sub_face = cv2.GaussianBlur(sub_face, (81, 81), 75)
# img_raw[y:y_plus_h, x:x_plus_w] = sub_face
cv2.rectangle(img_raw, (b[0], b[1]), (b[2], b[3]), (0, 0, 255), 2)
# save image
out_name = os.path.join(output_path, name)
cv2.imwrite(out_name, img_raw)
return bbox_res
def detect_faces(self, img_raw):
img = np.float32(img_raw)
im_height, im_width, _ = img.shape
scale = torch.Tensor(
[img.shape[1], img.shape[0], img.shape[1], img.shape[0]])
img -= (104, 117, 123)
img = img.transpose(2, 0, 1)
img = torch.from_numpy(img).unsqueeze(0)
if self.on_gpu:
img = img.to(self.device)
scale = scale.to(self.device)
# graph = 0
tic = time.time()
loc, conf, landms = self.detector(img) # forward pass
print('net forward time: {:.4f}'.format(time.time() - tic))
priorbox = PriorBox(self.cfg, image_size=(im_height, im_width))
priors = priorbox.forward()
if self.on_gpu:
priors = priors.to(self.device)
prior_data = priors.data
boxes = decode(loc.data.squeeze(0), prior_data, self.cfg['variance'])
boxes = boxes * scale / self.resize
boxes = boxes.cpu().numpy()
scores = conf.squeeze(0).data.cpu().numpy()[:, 1]
landms = decode_landm(landms.data.squeeze(0), prior_data,
self.cfg['variance'])
scale1 = torch.Tensor([
img.shape[3], img.shape[2], img.shape[3], img.shape[2],
img.shape[3], img.shape[2], img.shape[3], img.shape[2],
img.shape[3], img.shape[2]
])
if self.on_gpu:
scale1 = scale1.to(self.device)
landms = landms * scale1 / self.resize
landms = landms.cpu().numpy()
# ignore low scores
inds = np.where(scores > self.confidence_threshold)[0]
boxes = boxes[inds]
landms = landms[inds]
scores = scores[inds]
# keep top-K before NMS
order = scores.argsort()[::-1][:self.top_k]
boxes = boxes[order]
landms = landms[order]
scores = scores[order]
# do NMS
dets = np.hstack((boxes, scores[:, np.newaxis])).astype(np.float32,
copy=False)
keep = py_cpu_nms(dets, self.nms_threshold)
dets = dets[keep, :]
landms = landms[keep]
# keep top-K faster NMS
dets = dets[:self.keep_top_k, :]
landms = landms[:self.keep_top_k, :]
dets = np.concatenate((dets, landms), axis=1)
faces = []
for f in dets:
# fr: top, right, bottom, left
# retina: left, right, bottom, top
faces.append((int(f[1]), int(f[2]), int(f[3]), int(f[0])))
return faces
def run(args):
# net and load
cfg = cfg_mnet
net = RetinaFace(cfg=cfg, phase='test')
new_state_dict = load_normal(args.trained_model)
net.load_state_dict(new_state_dict)
print('Finished loading model!')
print(net)
torch.set_grad_enabled(False)
device = torch.device("cpu" if args.cpu else "cuda")
net = net.to(device)
input = torch.randn(1, 3, 270, 480).cuda()
flops, params = profile(net, inputs=(input, ))
print('flops:', flops, 'params:', params)
# testing dataset
with open(args.test_list_dir, 'r') as fr:
test_dataset = fr.read().split()
test_dataset.sort()
_t = {'forward_pass': Timer(), 'misc': Timer()}
# testing begin
if not os.path.isdir(args.save_folder):
os.makedirs(args.save_folder)
f_ = open(os.path.join(args.save_folder, 'vis_bbox.txt'), 'w')
net.eval()
for i, image_path in enumerate(test_dataset):
#img_name = os.path.split(image_path)[-1]
img_name = image_path[image_path.find('datasets') + 9:]
img_raw = cv2.imread(image_path, cv2.IMREAD_COLOR)
# img_raw = cv2.resize(img_raw, None, fx=1./3, fy=1.0/3, interpolation=cv2.INTER_AREA)
img = np.float32(img_raw)
# testing scale
target_size = 1600
max_size = 2150
im_shape = img.shape
im_size_min = np.min(im_shape[0:2])
im_size_max = np.max(im_shape[0:2])
resize = float(target_size) / float(im_size_min)
# prevent bigger axis from being more than max_size:
if np.round(resize * im_size_max) > max_size:
resize = float(max_size) / float(im_size_max)
if args.origin_size:
resize = 1
if resize != 1:
img = cv2.resize(img,
None,
None,
fx=resize,
fy=resize,
interpolation=cv2.INTER_LINEAR)
im_height, im_width, _ = img.shape
scale = torch.Tensor(
[img.shape[1], img.shape[0], img.shape[1], img.shape[0]])
img -= (104, 117, 123)
img = img.transpose(2, 0, 1)
img = torch.from_numpy(img).unsqueeze(0)
img = img.to(device)
scale = scale.to(device)
_t['forward_pass'].tic()
loc, conf, landms = net(img) # forward pass
_t['forward_pass'].toc()
_t['misc'].tic()
priorbox = PriorBox(cfg, image_size=(im_height, im_width))
priors = priorbox.forward()
priors = priors.to(device)
prior_data = priors.data
boxes = decode(loc.data.squeeze(0), prior_data, cfg['variance'])
boxes = boxes * scale / resize
boxes = boxes.cpu().numpy()
scores = conf.squeeze(0).data.cpu().numpy()[:, 1]
landms = decode_landm(landms.data.squeeze(0), prior_data,
cfg['variance'])
scale1 = torch.Tensor([
img.shape[3], img.shape[2], img.shape[3], img.shape[2],
img.shape[3], img.shape[2], img.shape[3], img.shape[2],
img.shape[3], img.shape[2]
])
scale1 = scale1.to(device)
landms = landms * scale1 / resize
landms = landms.cpu().numpy()
# ignore low scores
inds = np.where(scores > args.confidence_threshold)[0]
boxes = boxes[inds]
landms = landms[inds]
scores = scores[inds]
# keep top-K before NMS
order = scores.argsort()[::-1]
order = scores.argsort()[::-1][:args.top_k]
boxes = boxes[order]
landms = landms[order]
scores = scores[order]
# do NMS
dets = np.hstack((boxes, scores[:, np.newaxis])).astype(np.float32,
copy=False)
keep = py_cpu_nms(dets, args.nms_threshold)
# keep = nms(dets, args.nms_threshold,force_cpu=args.cpu)
dets = dets[keep, :]
landms = landms[keep]
# keep top-K faster NMS
dets = dets[:args.keep_top_k, :]
landms = landms[:args.keep_top_k, :]
dets = np.concatenate((dets, landms), axis=1)
_t['misc'].toc()
# --------------------------------------------------------------------
save_name = os.path.join(args.save_folder, 'txt',
img_name)[:-4] + '.txt'
dirname = os.path.dirname(save_name)
if not os.path.isdir(dirname):
os.makedirs(dirname)
with open(save_name, "w") as fd:
bboxs = dets
file_name = os.path.basename(save_name)[:-4] + "\n"
bboxs_num = str(len(bboxs)) + "\n"
fd.write(file_name)
fd.write(bboxs_num)
for box in bboxs:
x = int(box[0])
y = int(box[1])
w = int(box[2]) - int(box[0])
h = int(box[3]) - int(box[1])
confidence = str(box[4])
line = str(x) + " " + str(y) + " " + str(w) + " " + str(
h) + " " + confidence + " \n"
fd.write(line)
print('im_detect: {:d}/{:d}'
' forward_pass_time: {:.4f}s'
' misc: {:.4f}s'
' img_shape:{:}'.format(i + 1, len(test_dataset),
_t['forward_pass'].average_time,
_t['misc'].average_time, img.shape))
# save bbox-image
line_write = save_image(dets,
args.vis_thres,
img_raw,
args.save_folder,
img_name,
save_all=args.save_image_all)
f_.write(line_write)
f_.flush()
f_.close()
def detect_face(net, img):
img = np.float32(img_raw)
# testing scale
target_size = args.long_side
max_size = args.long_side
im_shape = img.shape
im_size_min = np.min(im_shape[0:2])
im_size_max = np.max(im_shape[0:2])
resize = float(target_size) / float(im_size_min)
# prevent bigger axis from being more than max_size:
if np.round(resize * im_size_max) > max_size:
resize = float(max_size) / float(im_size_max)
if args.origin_size:
resize = 1
if resize != 1:
img = cv2.resize(img,
None,
None,
fx=resize,
fy=resize,
interpolation=cv2.INTER_LINEAR)
# print("\nimg shape resize: ", img.shape)
im_height, im_width, _ = img.shape
scale = torch.Tensor(
[img.shape[1], img.shape[0], img.shape[1], img.shape[0]])
img -= (104, 117, 123)
img = img.transpose(2, 0, 1)
img = torch.from_numpy(img).unsqueeze(0)
img = img.to(device)
scale = scale.to(device)
tic = time.time()
loc, conf, landms = net(img) # forward pass
# print('net forward time: {:.4f}'.format(time.time() - tic))
tic = time.time()
priorbox = PriorBox(cfg, image_size=(im_height, im_width))
priors = priorbox.forward()
priors = priors.to(device)
prior_data = priors.data
boxes = decode(loc.data.squeeze(0), prior_data, cfg['variance'])
boxes = boxes * scale / resize
boxes = boxes.cpu().numpy()
scores = conf.squeeze(0).data.cpu().numpy()[:, 1]
landms = decode_landm(landms.data.squeeze(0), prior_data, cfg['variance'])
scale1 = torch.Tensor([
img.shape[3], img.shape[2], img.shape[3], img.shape[2], img.shape[3],
img.shape[2], img.shape[3], img.shape[2], img.shape[3], img.shape[2]
])
scale1 = scale1.to(device)
landms = landms * scale1 / resize
landms = landms.cpu().numpy()
# ignore low scores
inds = np.where(scores > args.confidence_threshold)[0]
boxes = boxes[inds]
landms = landms[inds]
scores = scores[inds]
# keep top-K before NMS
order = scores.argsort()[::-1][:args.top_k]
boxes = boxes[order]
landms = landms[order]
scores = scores[order]
# do NMS
dets = np.hstack((boxes, scores[:, np.newaxis])).astype(np.float32,
copy=False)
keep = py_cpu_nms(dets, args.nms_threshold)
# keep = nms(dets, args.nms_threshold,force_cpu=args.cpu)
dets = dets[keep, :]
landms = landms[keep]
# keep top-K faster NMS
dets = dets[:args.keep_top_k, :]
landms = landms[:args.keep_top_k, :]
dets = np.concatenate((dets, landms), axis=1)
# print('post processing time: {:.4f}'.format(time.time() - tic))
return dets
def val_to_text():
txt_origin_size = True
txt_confidence_threshold = 0.02
txt_nms_threshold = 0.4
txt_save_folder = args.save_folder + 'widerface_txt/'
testset_list = 'data/widerface/val/wider_val.txt'
testset_folder = 'data/widerface/val/images/'
with open(testset_list, 'r') as fr:
test_dataset = fr.read().split()
# testing begin
for i, img_name in enumerate(tqdm(test_dataset)):
image_path = testset_folder + img_name
img_raw = cv2.imread(image_path, cv2.IMREAD_COLOR)
img = np.float32(img_raw)
# testing scale
target_size = 1600
max_size = 2150
im_shape = img.shape
im_size_min = np.min(im_shape[0:2])
im_size_max = np.max(im_shape[0:2])
resize = float(target_size) / float(im_size_min)
# prevent bigger axis from being more than max_size:
if np.round(resize * im_size_max) > max_size:
resize = float(max_size) / float(im_size_max)
if txt_origin_size:
resize = 1
if resize != 1:
img = cv2.resize(img, None, None, fx=resize,
fy=resize, interpolation=cv2.INTER_LINEAR)
im_height, im_width, _ = img.shape
scale = torch.Tensor(
[img.shape[1], img.shape[0], img.shape[1], img.shape[0]])
img -= (104, 117, 123)
img = img.transpose(2, 0, 1)
img = torch.from_numpy(img).unsqueeze(0)
img = img.cuda()
scale = scale.cuda()
net.phase = 'test'
loc, conf, landms = net(img) # forward pass
net.phase = 'train'
priorbox = PriorBox(cfg, image_size=(im_height, im_width))
priors = priorbox.forward()
priors = priors.cuda()
prior_data = priors.data
boxes = decode(loc.data.squeeze(0), prior_data, cfg['variance'])
boxes = boxes * scale / resize
boxes = boxes.cpu().numpy()
scores = conf.squeeze(0).data.cpu().numpy()[:, 1]
landms = decode_landm(landms.data.squeeze(0),
prior_data, cfg['variance'])
scale1 = torch.Tensor([img.shape[3], img.shape[2], img.shape[3], img.shape[2],
img.shape[3], img.shape[2], img.shape[3], img.shape[2],
img.shape[3], img.shape[2]])
scale1 = scale1.cuda()
landms = landms * scale1 / resize
landms = landms.cpu().numpy()
# ignore low scores
inds = np.where(scores > txt_confidence_threshold)[0]
boxes = boxes[inds]
landms = landms[inds]
scores = scores[inds]
# keep top-K before NMS
order = scores.argsort()[::-1]
# order = scores.argsort()[::-1][:args.top_k]
boxes = boxes[order]
landms = landms[order]
scores = scores[order]
# do NMS
dets = np.hstack((boxes, scores[:, np.newaxis])).astype(
np.float32, copy=False)
keep = py_cpu_nms(dets, txt_nms_threshold)
# keep = nms(dets, args.nms_threshold,force_cpu=args.cpu)
dets = dets[keep, :]
landms = landms[keep]
# keep top-K faster NMS
# dets = dets[:args.keep_top_k, :]
# landms = landms[:args.keep_top_k, :]
dets = np.concatenate((dets, landms), axis=1)
# --------------------------------------------------------------------
save_name = txt_save_folder + img_name[:-4] + ".txt"
dirname = os.path.dirname(save_name)
if not os.path.isdir(dirname):
os.makedirs(dirname)
with open(save_name, "w") as fd:
bboxs = dets
file_name = os.path.basename(save_name)[:-4] + "\n"
bboxs_num = str(len(bboxs)) + "\n"
fd.write(file_name)
fd.write(bboxs_num)
for box in bboxs:
x = int(box[0])
y = int(box[1])
w = int(box[2]) - int(box[0])
h = int(box[3]) - int(box[1])
confidence = str(box[4])
line = str(x) + " " + str(y) + " " + str(w) + \
" " + str(h) + " " + confidence + " \n"
fd.write(line)
return txt_save_folder
# ignore low scores
inds = np.where(scores > args.confidence_threshold)[0]
boxes = boxes[inds]
landms = landms[inds]
scores = scores[inds]
# keep top-K before NMS
order = scores.argsort()[::-1][:args.top_k]
boxes = boxes[order]
landms = landms[order]
scores = scores[order]
# do NMS
dets = np.hstack((boxes, scores[:, np.newaxis])).astype(np.float32,
copy=False)
keep = py_cpu_nms(dets, args.nms_threshold)
# keep = nms(dets, args.nms_threshold,force_cpu=args.cpu)
dets = dets[keep, :]
landms = landms[keep]
# keep top-K faster NMS
dets = dets[:args.keep_top_k, :]
landms = landms[:args.keep_top_k, :]
dets = np.concatenate((dets, landms), axis=1)
# show image
if args.save_image:
for b in dets:
if b[4] < args.vis_thres:
continue
inds = np.where(scores > confidence_threshold)[0]
boxes = boxes[inds]
landms = landms[inds]
scores = scores[inds]
# keep top-K before NMS
order = scores.argsort()[::-1]
# order = scores.argsort()[::-1][:args.top_k]
boxes = boxes[order]
landms = landms[order]
scores = scores[order]
# do NMS
dets = np.hstack((boxes, scores[:, np.newaxis])).astype(np.float32,
copy=False)
keep = py_cpu_nms(dets, nms_threshold)
# keep = nms(dets, args.nms_threshold,force_cpu=args.cpu)
dets = dets[keep, :]
landms = landms[keep]
# keep top-K faster NMS
# dets = dets[:args.keep_top_k, :]
# landms = landms[:args.keep_top_k, :]
dets = np.concatenate((dets, landms), axis=1).astype(np.float32)
_t['misc'].toc()
# # --------------------------------------------------------------------
# save_name = args.save_folder + img_name[:-4] + ".txt"
# dirname = os.path.dirname(save_name)