def main(config: str = "config.yml"):
with open(config) as f:
cfg = yaml.safe_load(f)
enter_folder = cfg["ent_folder"]
out_folder = cfg["out_folder"]
mode = cfg["mode"]
make_dir_safe(out_folder)
detector = RetinaFace(cfg["name_det"], cfg["epoch_det"], cfg["gpu"])
align = Alinger(cfg["size"])
for race in tqdm(os.listdir(enter_folder)):
ent_race = os.path.join(enter_folder, race)
out_race = os.path.join(out_folder, race)
make_dir_safe(out_race)
for gender in os.listdir(ent_race):
ent_gender = os.path.join(ent_race, gender)
out_gender = os.path.join(out_race, gender)
make_dir_safe(out_gender)
faces = os.listdir(ent_gender)
faces.sort()
k = 0
out_faces = []
imgs = []
for face in tqdm(faces):
k += 1
ent_face = os.path.join(ent_gender, face)
out_face = os.path.join(out_gender, face)
img = cv2.imread(ent_face)
try:
img = cv2.resize(img, (500, 500))
det_img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
_, dets = detector.detect(det_img)
except cv2.error:
dets = np.empty((0, 1))
print(ent_face)
if dets.shape[0] != 1:
if mode == "unknown":
continue
imgs.append(0)
else:
lands = rework_landmarks(dets[0])
rew_imgs = align([img], [lands])
if mode == "unknown":
cv2.imwrite(out_face, rew_imgs[0][0][0])
continue
imgs.append(rew_imgs[0][0][0])
out_faces.append(out_face)
if k == 2 and mode == "known":
if not isinstance(imgs[0], int) and not isinstance(imgs[1], int):
for img, path in zip(imgs, out_faces):
cv2.imwrite(path, img)
imgs = []
out_faces = []
k = 0
class Detector:
def __init__(self, model_path):
self.model = RetinaFace(model_path, 0, ctx_id=0)
def get_face_patch(self, img):
bboxes, points = self.model.detect(img,
0.7,
scales=[1.0],
do_flip=False)
if isinstance(img, str):
img = cv2.imread(img)
faces_ = []
key_points_ = []
bboxes_ = []
for face, point in zip(bboxes, points):
#import pdb; pdb.set_trace()
bbox = face[0:4].astype(np.int)
to_add_face = img[bbox[1]:bbox[3], bbox[0]:bbox[2]]
to_add_face = cv2.cvtColor(to_add_face, cv2.COLOR_BGR2RGB)
faces_.append(to_add_face)
key_points_.append((points.astype(np.int), face[4]))
bboxes_.append(bbox)
#print(to_add_face.shape)
return faces_, np.array(key_points_), np.array(bboxes_)
def __init__(self, args):
self.args = args
ctx = mx.gpu(args.gpu)
_vec = args.image_size.split(',')
assert len(_vec) == 2
image_size = (int(_vec[0]), int(_vec[1]))
self.model = None
self.ga_model = None
if len(args.model) > 0:
self.model = get_model(ctx, image_size, args.model, 'fc1')
if len(args.ga_model) > 0:
self.ga_model = get_model(ctx, image_size, args.ga_model, 'fc1')
self.threshold = args.threshold
self.det_minsize = 50
self.det_threshold = args.det_threshold
#self.det_factor = 0.9
self.image_size = image_size
retina_path = args.detector_path
if args.det == 0:
detector = RetinaFace(retina_path, 0, ctx_id=0)
else:
raise ('Give detector path')
self.detector = detector
import cv2
import sys
import numpy as np
import datetime
import time
import os
import glob
sys.path.append('../../insightface')
from RetinaFace.retinaface import RetinaFace
thresh = 0.8
gpuid = 0
scales = [360, 640]
# detector = RetinaFace('./model/retinaface-R50/R50', 0, gpuid, 'net3')
detector = RetinaFace('./model/mnet.25/mnet.25', 0, gpuid, 'net3')
def detect_video(video_path):
cap = cv2.VideoCapture(video_path)
success, frame = cap.read()
im_shape = frame.shape
target_size = scales[0]
max_size = scales[1]
im_size_min = np.min(im_shape[0:2])
im_size_max = np.max(im_shape[0:2])
# im_scale = 1.0
# if im_size_min>target_size or im_size_max>max_size:
im_scale = float(target_size) / float(im_size_min)
# prevent bigger axis from being more than max_size:
if np.round(im_scale * im_size_max) > max_size:
parser.add_argument('-o',
'--output_folder',
default="./data/BIWI_prepared/",
help='Output file')
args = parser.parse_args()
# Input image file list
filenames = utils.get_list_from_filenames(
os.path.join(args.data_dir, "filename_list.txt"))
filenames = sorted(filenames)
random.shuffle(filenames)
# Init face detector
gpuid = 0
face_detector = RetinaFace('./RetinaFace/retinaface-R50', 0, gpuid, 'net3')
idx = -1
n_prrocessed = 0
examples = []
while True:
idx += 1
print("Processed: {}/{}".format(n_prrocessed, idx))
if idx < 0:
idx = 0
if idx >= len(filenames):
break
example = {}
import cv2
import numpy as np
from RetinaFace.retinaface import RetinaFace
gpuid = 0
# Road Face Detection Model
detector = RetinaFace('./model/R50', 0, gpuid, 'net3')
thresh = 0.8
sum_3 = 0
sum_4 = 0
sum_34 = 0
cap = cv2.VideoCapture(0)
frame_width = int(cap.get(3))
frame_height = int(cap.get(4))
# Read Cam
while (True):
ret, img = cap.read()
#print(np.shape(img))
faces, landmarks = detector.detect(img,
thresh,
scales=[1.0, 1.0],
do_flip=True)
if True:
for i in range(faces.shape[0]):
box = faces[i].astype(np.int)
color = (0, 0, 255)
def __init__(self, model_path):
self.model = RetinaFace(model_path, 0, ctx_id=0)
import cv2
import sys
import numpy as np
import datetime
import os
import glob
from RetinaFace.retinaface import RetinaFace
thresh = 0.8
scales = [1024, 1980]
count = 1
gpuid = 0
detector = RetinaFace(
'/home/yeluyue/dl/Datasets/ICCV_challenge/insightface-master/models/retinaface-R50/R50',
0, gpuid, 'net3')
img = cv2.imread(
'/home/yeluyue/yeluyue/DataSet/lfw/all/lfw_sor/val/Aaron_Eckhart/Aaron_Eckhart_0001.jpg'
)
print(img.shape)
im_shape = img.shape
target_size = scales[0]
max_size = scales[1]
im_size_min = np.min(im_shape[0:2])
im_size_max = np.max(im_shape[0:2])
#im_scale = 1.0
#if im_size_min>target_size or im_size_max>max_size:
im_scale = float(target_size) / float(im_size_min)
# prevent bigger axis from being more than max_size:
help='ver dist threshold')
args = ap.parse_args()
# Load embeddings and labels
data = pickle.loads(open(args.embeddings, "rb").read())
le = pickle.loads(open(args.le, "rb").read())
embeddings = np.array(data['embeddings'])
labels = le.fit_transform(data['names'])
# Initialize detector
thresh = 0.8
gpuid = 0
scales = [360, 640]
detector = RetinaFace('../insightface/RetinaFace/model/mnet.25/mnet.25', 0,
gpuid, 'net3')
cap = cv2.VideoCapture(args.video_in)
success, frame = cap.read()
im_shape = frame.shape
target_size = scales[0]
max_size = scales[1]
im_size_min = np.min(im_shape[0:2])
im_size_max = np.max(im_shape[0:2])
# im_scale = 1.0
# if im_size_min>target_size or im_size_max>max_size:
im_scale = float(target_size) / float(im_size_min)
# prevent bigger axis from being more than max_size:
if np.round(im_scale * im_size_max) > max_size:
im_scale = float(max_size) / float(im_size_max)
# Initialize faces embedding model
class FaceDetector():
def __init__(self, model_retina_path, gpu_id):
self.model = RetinaFace(model_retina_path,
0,
ctx_id=gpu_id,
network='net3')
def detect(self, img, scale_ratio=1.0):
ret = self.model.detect(img, 0.5, scales=[scale_ratio], do_flip=False)
if ret is None:
return [], []
bboxes, points = ret
if len(bboxes) == 0:
return [], []
return np.asarray(bboxes), points
def align(self, img, bbox=None, landmark=None, **kwargs):
M = None
image_size = []
str_image_size = kwargs.get('image_size', '')
if len(str_image_size) > 0:
image_size = [int(x) for x in str_image_size.split(',')]
if len(image_size) == 1:
image_size = [image_size[0], image_size[0]]
assert len(image_size) == 2
assert image_size[0] == 112
assert image_size[0] == 112 or image_size[1] == 96
if landmark is not None:
assert len(image_size) == 2
src = np.array(
[[30.2946, 51.6963], [65.5318, 51.5014], [48.0252, 71.7366],
[33.5493, 92.3655], [62.7299, 92.2041]],
dtype=np.float32)
if image_size[1] == 112:
src[:, 0] += 8.0
dst = landmark.astype(np.float32)
tform = trans.SimilarityTransform()
tform.estimate(dst, src)
M = tform.params[0:2, :]
#M = cv2.estimateRigidTransform( dst.reshape(1,5,2), src.reshape(1,5,2), False)
if M is None:
if bbox is None: #use center crop
det = np.zeros(4, dtype=np.int32)
det[0] = int(img.shape[1] * 0.0625)
det[1] = int(img.shape[0] * 0.0625)
det[2] = img.shape[1] - det[0]
det[3] = img.shape[0] - det[1]
else:
det = bbox
margin = kwargs.get('margin', 44)
bb = np.zeros(4, dtype=np.int32)
bb[0] = np.maximum(det[0] - margin / 2, 0)
bb[1] = np.maximum(det[1] - margin / 2, 0)
bb[2] = np.minimum(det[2] + margin / 2, img.shape[1])
bb[3] = np.minimum(det[3] + margin / 2, img.shape[0])
ret = img[bb[1]:bb[3], bb[0]:bb[2], :]
if len(image_size) > 0:
ret = cv2.resize(ret, (image_size[1], image_size[0]))
return ret
else: #do align using landmark
assert len(image_size) == 2
warped = cv2.warpAffine(img,
M, (image_size[1], image_size[0]),
borderValue=0.0)
return warped
def __init__(self, model_retina_path, gpu_id):
self.model = RetinaFace(model_retina_path,
0,
ctx_id=gpu_id,
network='net3')
def __init__(self,retina_path,request_add,det_threshold=0.8):
self.detector = RetinaFace(retina_path,0, ctx_id=0)
self.request_add = request_add
self.det_threshold = det_threshold
class Model:
def __init__(self,retina_path,request_add,det_threshold=0.8):
self.detector = RetinaFace(retina_path,0, ctx_id=0)
self.request_add = request_add
self.det_threshold = det_threshold
def check_mask(self,encoded_image):
r = requests.post(self.request_add,data=encoded_image)
result = r.json()['result']
return result
def get_face_patch(self,img):
bboxes,points = self.detector.detect(img, self.det_threshold,scales=[1.0],do_flip=False)
faces_=[]
key_points_=[]
bboxes_=[]
for face,point in zip(bboxes,points):
#import pdb; pdb.set_trace()
bbox = face[0:4].astype(np.int)
to_add_face=img[bbox[1]:bbox[3],bbox[0]:bbox[2]]
to_add_face = get_padded_image(to_add_face)[...,::-1]/255.0
# print(to_add_face.shape)
faces_.append(to_add_face)
key_points_.append((points.astype(np.int),face[4]))
bboxes_.append(bbox)
#print(to_add_face.shape)
return np.array(faces_),np.array(key_points_),np.array(bboxes_)
def generate_output(self,read_path,write_path,type_='video'):
if type_ == 'video':
self.generate_video(read_path,write_path)
else:
self.generate_image(read_path,write_path)
def generate_video(self,read_path,write_path):
cap = cv2.VideoCapture(read_path)
fourcc = cv2.VideoWriter_fourcc(*'XVID')
fps = cap.get(cv2.CAP_PROP_FPS)
ret , fr = cap.read()
org_h,org_w = fr.shape[:2]
out = cv2.VideoWriter(f'{write_path}', fourcc, fps, (org_w,org_h))
counter = 0
while ret:
if counter%2 == 0:
counter = 0
fr = self._infer_on_frame(fr)
out.write(fr)
ret,fr = cap.read()
counter += 1
out.release()
def generate_image(self,read_path,write_path):
fr = cv2.imread(read_path)
if fr is None:
print('Invalid Image')
return
fr = self._infer_on_frame(fr)
plt.imsave(write_path,fr[:,:,::-1])
def _infer_on_frame(self,fr):
# org_h,org_w = fr.shape[:2]
# fr = imutils.resize(fr,width=720)
faces , keypoints , bboxes = self.get_face_patch(fr)
if not len(faces)==0:
encoded_arr = pickle.dumps(faces)
output = self.check_mask(encoded_arr)
for out,bbox in zip(output,bboxes):
# for bbox in bboxes:
x1,y1,x2,y2 = bbox
if out == 'mask':
color = (0,255,0)
else:
color = (0,0,255)
#color = (0,255,0)
fr = cv2.rectangle(fr.copy(),(x1,y1),(x2,y2),color,2)
# fr = cv2.resize(fr.copy(),(org_w,org_h))
return fr
# Build model
net = models.HeadPoseNet(config["model"]["im_width"],
config["model"]["im_height"],
nb_bins=config["model"]["nb_bins"],
learning_rate=config["train"]["learning_rate"],
backbond=config["model"]["backbond"])
# Load model
net.load_weights(config["test"]["model_file"])
cap = cv2.VideoCapture(0)
if not cap.isOpened():
print("Unable to connect to camera.")
exit(-1)
face_detector = RetinaFace('./RetinaFace/retinaface-R50', 0, 0, 'net3')
while cap.isOpened():
ret, frame = cap.read()
if ret:
faces, landmarks = face_detector.detect(frame,
0.8,
scales=[1.0],
do_flip=False)
if len(faces) > 0:
face_crops = []
face_boxes = []
for i in range(len(faces)):
bbox = faces[i]
import cv2
import sys
import numpy as np
import datetime
import os
import glob
from RetinaFace.retinaface import RetinaFace
thresh = 0.8
scales = [1024, 1980]
count = 1
gpuid = 0
#detector = RetinaFace('./model/resnet-50', 0, gpuid, 'net3')
detector = RetinaFace('./mnet.25/mnet.25', 0, gpuid, 'net3')
img = cv2.imread('t1.jpg')
print(img.shape)
im_shape = img.shape
target_size = scales[0]
max_size = scales[1]
im_size_min = np.min(im_shape[0:2])
im_size_max = np.max(im_shape[0:2])
#im_scale = 1.0
#if im_size_min>target_size or im_size_max>max_size:
im_scale = float(target_size) / float(im_size_min)
# prevent bigger axis from being more than max_size:
if np.round(im_scale * im_size_max) > max_size:
im_scale = float(max_size) / float(im_size_max)
def test(args):
print('test with', args)
global detector
output_folder = args.output
if not os.path.exists(output_folder):
os.mkdir(output_folder)
detector = RetinaFace(args.prefix,
args.epoch,
args.gpu,
network=args.network,
nocrop=args.nocrop,
vote=args.bbox_vote)
imdb = eval(args.dataset)(args.image_set, args.root_path,
args.dataset_path)
roidb = imdb.gt_roidb()
gt_overlaps = np.zeros(0)
overall = [0.0, 0.0]
gt_max = np.array((0.0, 0.0))
num_pos = 0
print('roidb size', len(roidb))
for i in range(len(roidb)):
if i % args.parts != args.part:
continue
#if i%10==0:
# print('processing', i, file=sys.stderr)
roi = roidb[i]
boxes = get_boxes(roi, args.pyramid)
if 'boxes' in roi:
gt_boxes = roi['boxes'].copy()
gt_areas = (gt_boxes[:, 2] - gt_boxes[:, 0] +
1) * (gt_boxes[:, 3] - gt_boxes[:, 1] + 1)
num_pos += gt_boxes.shape[0]
overlaps = bbox_overlaps(boxes.astype(np.float),
gt_boxes.astype(np.float))
#print(im_info, gt_boxes.shape, boxes.shape, overlaps.shape, file=sys.stderr)
_gt_overlaps = np.zeros((gt_boxes.shape[0]))
if boxes.shape[0] > 0:
_gt_overlaps = overlaps.max(axis=0)
#print('max_overlaps', _gt_overlaps, file=sys.stderr)
for j in range(len(_gt_overlaps)):
if _gt_overlaps[j] > 0.5:
continue
#print(j, 'failed', gt_boxes[j], 'max_overlap:', _gt_overlaps[j], file=sys.stderr)
# append recorded IoU coverage level
found = (_gt_overlaps > 0.5).sum()
recall = found / float(gt_boxes.shape[0])
#print('recall', _recall, gt_boxes.shape[0], boxes.shape[0], gt_areas, 'num:', i, file=sys.stderr)
overall[0] += found
overall[1] += gt_boxes.shape[0]
#gt_overlaps = np.hstack((gt_overlaps, _gt_overlaps))
#_recall = (gt_overlaps >= threshold).sum() / float(num_pos)
recall_all = float(overall[0]) / overall[1]
#print('recall_all', _recall, file=sys.stderr)
print('[%d]' % i,
'recall',
recall, (gt_boxes.shape[0], boxes.shape[0]),
'all:',
recall_all,
file=sys.stderr)
else:
print('[%d]' % i, 'detect %d faces' % boxes.shape[0])
_vec = roidb[i]['image'].split('/')
out_dir = os.path.join(output_folder, _vec[-2])
if not os.path.exists(out_dir):
os.mkdir(out_dir)
out_file = os.path.join(out_dir, _vec[-1].replace('jpg', 'txt'))
with open(out_file, 'w') as f:
name = '/'.join(roidb[i]['image'].split('/')[-2:])
f.write("%s\n" % (name))
f.write("%d\n" % (boxes.shape[0]))
for b in range(boxes.shape[0]):
box = boxes[b]
f.write(
"%d %d %d %d %g \n" %
(box[0], box[1], box[2] - box[0], box[3] - box[1], box[4]))